juce Namespace Reference

Namespaces
namespace	FloatVectorHelpers
namespace	detail
namespace	MidiBufferHelpers
namespace	MidiFileHelpers
namespace	MidiHelpers
namespace	universal_midi_packets
namespace	ValueSmoothingTypes
namespace	SampleRateHelpers
namespace	ASIODebugging
namespace	DSoundLogging
namespace	WasapiClasses
namespace	AiffFileHelpers
namespace	WavFileHelpers
namespace	WindowsMediaCodec
namespace	lv2_shared
namespace	lv2
namespace	ModelUpdateControllerProgressAdapter
namespace	MimeTypeTable
namespace	TokenTypes
namespace	TypeHelpers
namespace	AtomicHelpers
namespace	HeapBlockHelper
namespace	WindowsFileHelpers
namespace	MACAddressHelpers
namespace	SocketHelpers
namespace	URLHelpers
namespace	internal
namespace	NumberToStringConverters
namespace	StringHelpers
namespace	TimeHelpers
namespace	UnitTestCategories
namespace	XmlIdentifierChars
namespace	XmlOutputFunctions
namespace	zlibNamespace
namespace	PropertyFileConstants
namespace	ValueTreeSynchroniserHelpers
namespace	dsp
namespace	LinuxEventLoop
namespace	LinuxErrorHandling
namespace	ColourHelpers
namespace	Colours
namespace	CustomTypefaceHelpers
namespace	FontValues
namespace	TextLayoutHelpers
namespace	PathHelpers
namespace	PathStrokeHelpers
namespace	jpeglibNamespace
namespace	JPEGHelpers
namespace	pnglibNamespace
namespace	PNGHelpers
namespace	RenderingHelpers
namespace	TTFNameExtractor
namespace	FontEnumerators
namespace	StandardApplicationCommandIDs
namespace	FocusHelpers
namespace	KeyboardFocusTraverserHelpers
namespace	KeyPressHelpers
namespace	AnimatedPositionBehaviours
namespace	ComponentBuilderHelpers
namespace	MultiDocHelpers
namespace	TabbedComponentHelpers
namespace	LookAndFeelHelpers
namespace	PopupMenuSettings
namespace	WindowsAccessibility
namespace	ComTypes
namespace	VariantHelpers
namespace	DragAndDropHelpers
namespace	IconConverters
namespace	X11SymbolHelpers
namespace	ReturnHelpers
namespace	X11ErrorHandling
namespace	Keys
namespace	Visuals
namespace	DisplayHelpers
namespace	PixmapHelpers
namespace	ClipboardHelpers
namespace	XWindowSystemUtilities
namespace	RelativePointHelpers
namespace	RelativeRectangleHelpers
namespace	TextEditorDefs
namespace	AlertWindowMappings
namespace	DragHelpers
namespace	CodeEditorHelpers
namespace	PushNotificationsDelegateDetailsOsx
namespace	ActiveXHelpers

Classes
class	AudioPlayHead
class	AudioChannelSet
class	AudioData
class	AudioDataConverters
class	AudioProcessLoadMeasurer
class	AudioBuffer
struct	FloatVectorOperationsBase
class	FloatVectorOperations
class	ScopedNoDenormals
struct	MidiMessageMetadata
class	MidiBufferIterator
class	MidiBuffer
class	MidiDataConcatenator
class	MidiFile
class	MidiKeyboardState
class	MidiMessage
class	OptionalPitchWheel
class	OptionalControllerValues
class	OptionalProgramChange
class	ParameterNumberState
class	MidiMessageSequence
struct	MidiRPNMessage
class	MidiRPNDetector
class	MidiRPNGenerator
class	MPEInstrument
class	MPEMessages
struct	MPENote
class	MPESynthesiser
struct	MPESynthesiserBase
class	MPESynthesiserVoice
class	MPEChannelAssigner
class	MPEChannelRemapper
class	MPEValue
struct	MPEZone
class	MPEZoneLayout
struct	CoreAudioTimeConversions
struct	AudioSourceChannelInfo
class	AudioSource
class	BufferingAudioSource
class	ChannelRemappingAudioSource
class	IIRFilterAudioSource
class	MemoryAudioSource
class	MixerAudioSource
class	PositionableAudioSource
class	ResamplingAudioSource
class	ReverbAudioSource
class	ToneGeneratorAudioSource
class	SynthesiserSound
class	SynthesiserVoice
class	Synthesiser
class	ADSR
struct	ADSRTests
class	Decibels
class	GenericInterpolator
class	IIRCoefficients
class	IIRFilterBase
class	IIRFilter
class	SingleThreadedIIRFilter
class	Interpolators
struct	LagrangeResampleHelper
struct	LagrangeResampleHelper< 0 >
class	Reverb
class	SmoothedValueBase
class	SmoothedValue
class	AudioDeviceManager
struct	AudioIODeviceCallbackContext
class	AudioIODeviceCallback
class	AudioIODevice
class	AudioIODeviceType
class	SystemAudioVolume
struct	MidiDeviceInfo
class	MidiInput
class	MidiInputCallback
class	MidiOutput
class	MidiMessageCollector
class	BelaAudioIODevice
struct	BelaAudioIODeviceType
struct	JackPortIterator
class	JackAudioIODevice
class	JackAudioIODeviceType
struct	AsyncRestarter
struct	SystemVol
struct	CoreAudioClasses
struct	ASIOSampleFormat
class	ASIOAudioIODevice
class	ASIOAudioIODeviceType
class	DSoundInternalOutChannel
struct	DSoundInternalInChannel
class	DSoundAudioIODevice
struct	DSoundDeviceList
class	DSoundAudioIODeviceType
struct	MidiServiceType
struct	Win32MidiService
struct	MidiService
struct	IMMDeviceCollection
struct	AudioClientProperties
class	AudioSourcePlayer
class	AudioTransportSource
class	AiffAudioFormatReader
class	AiffAudioFormatWriter
class	MemoryMappedAiffReader
class	AiffAudioFormat
class	WavAudioFormatReader
class	WavAudioFormatWriter
class	MemoryMappedWavReader
class	WavAudioFormat
class	ARAAudioSourceReader
class	ARAPlaybackRegionReader
class	AudioFormat
class	AudioFormatManager
class	AudioFormatReader
class	AudioFormatReaderSource
class	AudioFormatWriter
class	AudioSubsectionReader
class	BufferingAudioReader
class	MemoryMappedAudioFormatReader
class	SamplerSound
class	SamplerVoice
class	AudioPluginFormat
class	AudioPluginFormatManager
class	ARAFactoryWrapper
struct	ARAFactoryResult
struct	AudioUnitHelpers
class	LegacyAudioParameter
class	LegacyAudioParametersWrapper
class	LV2PluginFormatTests
class	QueryInterfaceResult
class	InterfaceResultWithDeferredAddRef
struct	UniqueBase
struct	SharedBase
struct	ChannelMapping
class	DynamicChannelMapping
class	ScratchBuffer
class	ClientBufferMapperData
class	ClientBufferMapper
class	ClientRemappedBuffer
class	HostBufferMapper
class	VSTComSmartPtr
class	StoredMidiMapping
class	MidiEventList
class	CachedParamValues
class	ComponentRestarter
class	VST3PluginFormatTests
struct	SpeakerMappings
class	VSTMidiEventList
class	AudioPluginInstance
class	AudioProcessor
class	AudioProcessorEditor
struct	HostProvidedContextMenu
struct	AudioProcessorEditorHostContext
struct	GraphRenderSequence
struct	RenderSequenceBuilder
class	AudioProcessorGraph
class	AudioProcessorListener
class	AudioProcessorParameter
class	AudioProcessorParameterGroup
class	ParameterListener
class	ParameterComponent
class	BooleanParameterComponent
class	SwitchParameterComponent
class	ChoiceParameterComponent
class	SliderParameterComponent
class	ParameterDisplayComponent
struct	ParamControlItem
struct	ParameterGroupItem
class	GenericAudioProcessorEditor
struct	HostedAudioProcessorParameter
class	PluginDescription
struct	PluginSorter
struct	PluginTreeUtils
class	KnownPluginList
class	PluginDirectoryScanner
class	PluginListComponent
class	ARADocumentControllerSpecialisation
class	ARAInputStream
class	ARAOutputStream
class	ARADocumentController
class	ARAListenableModelClass
class	ARAObjectVisitor
class	ARAObject
class	ARADocumentListener
class	ARADocument
class	ARAMusicalContextListener
class	ARAMusicalContext
class	ARAPlaybackRegionListener
class	ARAPlaybackRegion
class	ARARegionSequenceListener
class	ARARegionSequence
class	ARAAudioSourceListener
class	ARAAudioSource
class	ARAAudioModificationListener
class	ARAAudioModification
class	ARARenderer
class	ARAPlaybackRenderer
class	ARAEditorRenderer
class	ARAEditorView
class	AudioProcessorARAExtension
class	AudioProcessorEditorARAExtension
class	AudioParameterBoolAttributes
class	AudioParameterBool
class	AudioParameterChoiceAttributes
class	AudioParameterChoice
class	AudioParameterFloatAttributes
class	AudioParameterFloat
class	AudioParameterIntAttributes
class	AudioParameterInt
class	ParameterID
class	AudioProcessorParameterWithIDAttributes
class	AudioProcessorParameterWithID
class	AudioProcessorValueTreeStateParameterAttributes
class	AudioProcessorValueTreeState
struct	ExtensionsVisitor
class	FlagCache
class	FlaggedFloatCache
class	NativeScaleFactorNotifier
class	ParameterAttachment
class	SliderParameterAttachment
class	ComboBoxParameterAttachment
class	ButtonParameterAttachment
class	PluginHostType
class	RangedAudioParameterAttributes
class	RangedAudioParameter
struct	VST3ClientExtensions
struct	VSTCallbackHandler
class	AbstractFifo
class	Array
class	ArrayAllocationBase
class	ArrayBase
class	DynamicObject
struct	SortFunctionConverter
class	DefaultElementComparator
struct	DefaultHashFunctions
class	HashMap
struct	HashMapTest
class	LinkedListPointer
class	ListenerList
class	NamedValueSet
struct	Nullopt
class	Optional
struct	ThrowOnMoveOrSwap
class	OptionalUnitTest
class	OwnedArray
class	PropertySet
class	ReferenceCountedArray
class	ScopedValueSetter
class	SingleThreadedAbstractFifo
class	SortedSet
class	SparseSet
class	var
struct	VariantConverter
struct	VariantConverter< String >
class	AndroidDocumentInfo
class	AndroidDocumentPermission
class	AndroidDocument
class	AndroidDocumentIterator
struct	MimeTypeTableEntry
class	DirectoryIterator
class	File
class	FileFilter
class	FileInputStream
class	FileOutputStream
class	FileSearchPath
class	MemoryMappedFile
class	DirectoryEntry
class	RangedDirectoryIterator
class	LockedRandom
class	TemporaryFile
class	WildcardFileFilter
class	JavascriptEngine
struct	JSONParser
struct	JSONFormatter
class	JSON
struct	this_will_fail_to_link_if_some_of_your_compile_units_are_built_in_release_mode
class	FileLogger
class	Logger
class	BigInteger
class	Expression
struct	MathConstants
class	NormalisableRange
class	Random
class	Range
class	StatisticsAccumulator
struct	Atomic
class	ByteOrder
struct	ContainerDeletePolicy
class	HeapBlock
class	HeavyweightLeakedObjectDetector
class	LeakedObjectDetector
class	MemoryBlock
class	OptionalScopedPointer
class	ReferenceCountedObject
class	SingleThreadedReferenceCountedObject
class	ReferenceCountedObjectPtr
struct	Reservoir
class	ScopedPointer
class	SharedResourcePointer
struct	SingletonHolder
class	WeakReference
struct	ConsoleAppFailureCode
struct	ArgumentList
struct	ConsoleApplication
struct	NullCheckedInvocation
class	Result
class	RuntimePermissions
class	Uuid
struct	CURLSymbols
struct	CFObjectDeleter
struct	CFObjectHolder
struct	MetaSuperFn
struct	NSObjectDeleter
class	ObjCObjectHandle
struct	ObjCClass
struct	ObjCLifetimeManagedClass
class	ObjCBlock
struct	UUIDGetter
struct	UUIDGetter<::IUnknown >
class	ComSmartPtr
class	ComBaseClassHelperBase
class	ComBaseClassHelper
struct	GetAdaptersAddressesHelper
struct	RegistryKeyWrapper
class	HiResCounterHandler
struct	SleepEvent
union	IPAddressByteUnion
class	IPAddress
class	MACAddress
class	NamedPipe
class	StreamingSocket
class	DatagramSocket
class	URL
class	WebInputStream
class	BufferedInputStream
class	FileInputSource
class	InputSource
class	InputStream
class	MemoryInputStream
class	MemoryOutputStream
class	OutputStream
class	SubregionStream
class	URLInputSource
struct	CPUInformation
class	SystemStats
struct	Base64
class	CharacterFunctions
class	CharPointer_ASCII
class	CharPointer_UTF16
class	CharPointer_UTF32
class	CharPointer_UTF8
class	Identifier
class	LocalisedStrings
class	NewLine
struct	StringHolder
class	StringHolderUtils
struct	HashGenerator
struct	WildCardMatcher
struct	StringCreationHelper
struct	StringEncodingConverter
struct	StringEncodingConverter< CharPointer_UTF8, CharPointer_UTF8 >
struct	StringEncodingConverter< CharPointer_UTF16, CharPointer_UTF16 >
struct	StringEncodingConverter< CharPointer_UTF32, CharPointer_UTF32 >
struct	StringCopier
class	String
class	StringArray
class	StringPairArray
struct	StartEndString
class	StringPool
class	StringRef
struct	TextDiffHelpers
class	TextDiff
class	ChildProcess
class	CriticalSection
class	DummyCriticalSection
class	DynamicLibrary
class	HighResolutionTimer
class	InterProcessLock
class	Process
class	ReadWriteLock
class	GenericScopedLock
class	GenericScopedUnlock
class	GenericScopedTryLock
class	ScopedReadLock
class	ScopedTryReadLock
class	ScopedWriteLock
class	ScopedTryWriteLock
class	SpinLock
struct	CurrentThreadHolder
struct	LambdaThread
class	Thread
class	ThreadLocalValue
class	ThreadPoolJob
class	ThreadPool
class	TimeSliceClient
class	TimeSliceThread
class	WaitableEvent
class	PerformanceCounter
class	ScopedTimeMeasurement
class	RelativeTime
class	Time
class	UnitTest
class	UnitTestRunner
class	XmlDocument
class	XmlElement
class	GZIPCompressorOutputStream
class	GZIPDecompressorInputStream
class	ZipFile
class	ApplicationProperties
class	PropertiesFile
class	UndoableAction
class	UndoManager
class	CachedValue
class	SimpleValueSource
class	Value
struct	ValueTreePropertyValueSource
class	ValueTree
class	ValueTreePropertyWithDefault
class	ValueTreePropertyWithDefaultTests
class	ValueTreeSynchroniser
class	ActionBroadcaster
class	ActionListener
class	AsyncUpdater
class	ChangeBroadcaster
class	ChangeListener
struct	ChildProcessPingThread
class	ChildProcessWorker
class	ChildProcessCoordinator
class	SafeActionImpl
struct	ConnectionStateMessage
struct	DataDeliveryMessage
class	InterprocessConnection
class	InterprocessConnectionServer
struct	NetworkServiceDiscovery
class	JUCEApplicationBase
class	CallbackMessage
class	DeletedAtShutdown
class	ScopedJuceInitialiser_GUI
class	Message
class	MessageListener
class	AsyncFunctionCallback
class	MessageManager
class	MessageManagerLock
struct	LinuxEventLoopInternal
class	InternalMessageQueue
struct	InternalRunLoop
class	MessageQueue
class	ScopedLowPowerModeDisabler
class	HiddenMessageWindow
class	JuceWindowIdentifier
class	DeviceChangeDetector
class	WinRTWrapper
struct	MultiTimerCallback
class	MultiTimer
struct	LambdaInvoker
class	Timer
class	Colour
class	ColourGradient
class	FillType
class	PixelARGB
class	PixelRGB
class	PixelAlpha
struct	GraphicsFontHelpers
class	Graphics
class	LowLevelGraphicsContext
class	LowLevelGraphicsPostScriptRenderer
class	LowLevelGraphicsSoftwareRenderer
struct	DropShadow
class	DropShadowEffect
class	GlowEffect
class	ImageEffectFilter
class	AttributedString
class	CustomTypeface
class	TypefaceCache
struct	FontPlaceholderNames
class	Font
class	PositionedGlyph
class	GlyphArrangement
class	TextLayout
struct	FontStyleHelpers
class	Typeface
class	AffineTransform
class	BorderSize
class	EdgeTable
class	Line
class	Parallelogram
class	Path
class	PathFlatteningIterator
class	PathStrokeType
class	Point
class	Rectangle
struct	RectangleUnitTest
class	RectangleList
class	GIFLoader
class	SoftwarePixelData
class	SubsectionPixelData
struct	PixelIterator
struct	AlphaMultiplyOp
struct	DesaturateOp
class	Image
class	ImagePixelData
class	ImageType
class	SoftwareImageType
class	NativeImageType
class	ImageCache
class	ImageConvolutionKernel
struct	DefaultImageFormats
class	ImageFileFormat
class	PNGImageFormat
class	JPEGImageFormat
class	GIFImageFormat
class	ScaledImage
struct	FTLibWrapper
struct	FTFaceWrapper
class	FTTypefaceList
class	FreeTypeTypeface
struct	DefaultFontInfo
class	CoreGraphicsContext
class	Direct2DLowLevelGraphicsContext
struct	DefaultFontNames
class	WindowsTypeface
class	Justification
class	RectanglePlacement
class	AccessibilityActions
class	AccessibilityCellInterface
class	AccessibilityTableInterface
class	AccessibilityTextInterface
class	AccessibilityValueInterface
class	AccessibilityTextValueInterface
class	AccessibilityNumericValueInterface
class	AccessibilityRangedNumericValueInterface
class	AccessibilityHandler
class	AccessibleState
class	JUCEApplication
class	ArrowButton
class	ButtonAccessibilityHandler
class	Button
class	DrawableButton
class	HyperlinkButton
class	ImageButton
class	ShapeButton
class	TextButton
class	ToggleButton
class	ToolbarButton
struct	ApplicationCommandInfo
class	ApplicationCommandManager
class	ApplicationCommandManagerListener
class	ApplicationCommandTarget
class	KeyPressMappingSet
class	CachedComponentImage
struct	FocusRestorer
struct	ScalingHelpers
struct	StandardCachedComponentImage
class	Component
class	ComponentListener
class	ComponentTraverser
class	FocusTraverser
class	ModalComponentManager
class	ModalCallbackFunction
class	FocusChangeListener
class	DarkModeSettingListener
class	Desktop
struct	DisplayNode
class	Displays
class	Drawable
class	DrawableComposite
class	DrawableImage
class	DrawablePath
class	DrawableRectangle
class	DrawableShape
class	DrawableText
class	SVGState
class	ContentSharer
class	DirectoryContentsDisplayComponent
class	DirectoryContentsList
class	FileBrowserComponent
class	FileBrowserListener
class	FileChooser
class	FileChooserDialogBox
class	FileListComponent
class	FilenameComponentListener
class	FilenameComponent
class	FilePreviewComponent
class	FileSearchPathListComponent
class	FileListTreeItem
class	FileTreeComponent
class	ImagePreviewComponent
struct	CustomMouseCursorInfo
class	CaretComponent
class	KeyboardFocusTraverser
class	KeyListener
class	KeyPress
class	ModifierKeys
class	SystemClipboard
struct	TextEditorKeyMapper
class	TextInputTarget
class	AnimatedPosition
class	ComponentAnimator
class	ComponentBoundsConstrainer
class	ComponentBuilder
class	ComponentMovementWatcher
class	ConcertinaPanel
struct	FlexBoxLayoutCalculation
class	FlexBox
class	FlexItem
struct	AllTracksIncludingImplicit
struct	Tracks
class	Grid
class	GridItem
class	GroupComponent
class	MultiDocumentPanelWindow
class	MultiDocumentPanel
class	ResizableBorderComponent
class	ResizableCornerComponent
class	ResizableEdgeComponent
class	ScrollBar
class	SidePanel
class	StretchableLayoutManager
class	StretchableLayoutResizerBar
class	StretchableObjectResizer
class	TabBarButton
class	TabbedButtonBar
class	TabbedComponent
class	Viewport
struct	ExtraLookAndFeelBaseClasses
class	LookAndFeel
class	LookAndFeel_V1
class	LookAndFeel_V2
class	LookAndFeel_V3_DocumentWindowButton
class	LookAndFeel_V3
class	LookAndFeel_V4_DocumentWindowButton
class	LookAndFeel_V4
struct	CustomMenuBarItemHolder
class	BurgerMenuComponent
class	MenuBarComponent
class	MenuBarModel
struct	PopupMenuCompletionCallback
class	PopupMenu
class	BubbleComponent
class	DropShadower
struct	OutlineWindowComponent
class	FocusOutline
class	JUCESplashScreen
class	ComponentDragger
class	DragAndDropContainer
class	DragAndDropTarget
class	FileDragAndDropTarget
class	LassoSource
class	LassoComponent
class	MouseCursor
class	MouseEvent
struct	MouseWheelDetails
struct	PenDetails
class	MouseInactivityDetector
class	MouseInputSourceInternal
class	MouseInputSource
class	MouseListener
class	PointerState
class	SelectedItemSet
class	TextDragAndDropTarget
class	TooltipClient
class	SettableTooltipClient
struct	AccessibilityTextHelpers
class	AccessibilityNativeHandle
struct	SpVoiceWrapper
class	UIAExpandCollapseProvider
class	UIAGridItemProvider
class	UIAGridProvider
class	UIAInvokeProvider
class	UIAProviderBase
class	UIARangeValueProvider
class	UIASelectionItemProvider
class	UIASelectionProvider
class	UIATextProvider
class	UIAToggleProvider
class	UIATransformProvider
class	UIAValueProvider
class	UIAWindowProvider
class	WindowsUIAWrapper
class	LinuxComponentPeer
class	CoreGraphicsMetalLayerRenderer
class	MultiTouchMapper
class	ScopedDPIAwarenessDisabler
class	Win32NativeFileChooser
class	ScopedThreadDPIAwarenessSetter
struct	ScopedDeviceContext
struct	TOUCHINPUT
struct	GESTUREINFO
struct	POINTER_INFO
struct	POINTER_TOUCH_INFO
struct	POINTER_PEN_INFO
class	WindowsBitmapImage
struct	IInspectable
struct	UWPUIViewSettings
class	HWNDComponentPeer
class	WindowsMessageBoxBase
class	PreVistaMessageBox
class	WindowsTaskDialog
class	ScreenSaverDefeater
struct	MonitorInfo
class	X11DragState
class	X11Symbols
struct	MotifWmHints
class	XBitmapImage
class	XWindowSystem
class	MarkerList
class	RelativeCoordinate
struct	MarkerListScope
class	RelativeCoordinatePositionerBase
class	RelativeParallelogram
class	RelativePoint
class	RelativePointPath
class	RelativeRectangleLocalScope
class	RelativeRectangleComponentPositioner
class	RelativeRectangle
class	BooleanPropertyComponent
class	ButtonPropertyComponent
class	ChoiceRemapperValueSource
class	ChoiceRemapperValueSourceWithDefault
class	ChoicePropertyComponent
class	StringComparator
class	MultiChoicePropertyComponent
class	PropertyComponent
class	PropertyPanel
class	SliderPropertyComponent
class	TextRemapperValueSourceWithDefault
class	TextPropertyComponent
class	ComboBoxAccessibilityHandler
class	ComboBox
class	ImageComponent
class	LabelKeyboardFocusTraverser
class	LabelAccessibilityHandler
class	Label
struct	ListBoxMouseMoveSelector
class	ListBoxModel
class	ListBox
class	ProgressBar
class	SliderAccessibilityHandler
class	Slider
class	TableHeaderComponent
class	TableListBoxModel
class	TableListBox
struct	TextAtom
class	TextEditor
class	Toolbar
class	ToolbarItemComponent
class	ToolbarItemFactory
class	ToolbarItemPalette
class	TreeViewItem
class	TreeView
class	AlertTextComp
class	AlertWindowInfo
class	AlertWindow
class	CallOutBoxCallback
class	CallOutBox
class	ComponentPeer
class	DefaultDialogWindow
class	DialogWindow
class	DocumentWindow
class	MessageBoxOptions
class	NativeMessageBox
class	ResizableWindow
class	ThreadWithProgressWindow
class	TooltipWindow
class	TopLevelWindowManager
class	TopLevelWindow
class	CodeDocumentLine
class	CodeDocument
class	CodeEditorComponent
class	CodeTokeniser
class	CPlusPlusCodeTokeniser
struct	CppTokeniserFunctions
struct	LuaTokeniserFunctions
class	LuaTokeniser
class	XmlTokeniser
class	FileBasedDocument
class	AnimatedAppComponent
class	BubbleMessageComponent
struct	ColourComponentSlider
class	ColourSelector
class	KeyMappingEditorComponent
class	PreferencesPanel
class	PushNotifications
class	RecentlyOpenedFilesList
class	SplashScreen
class	WebKitSymbols
class	CommandReceiver
class	GtkChildProcess
struct	PushNotificationsDelegate
struct	StatusItemContainer
struct	InternalWebViewType
class	Win32WebView

Typedefs
using	AudioSampleBuffer = AudioBuffer<float>
using	MidiKeyboardStateListener = MidiKeyboardState::Listener
using	WindowedSincInterpolator = Interpolators::WindowedSinc
using	LagrangeInterpolator = Interpolators::Lagrange
using	CatmullRomInterpolator = Interpolators::CatmullRom
using	LinearInterpolator = Interpolators::Linear
using	ZeroOrderHoldInterpolator = Interpolators::ZeroOrderHold
template<typename FloatType>
using	LinearSmoothedValue = SmoothedValue <FloatType, ValueSmoothingTypes::Linear>
using	REFERENCE_TIME = LONGLONG
using	StringMap = std::unordered_map<String, String>
typedef ComponentPeer *(*	createUnityPeerFunctionType) (Component &)
using	int8 = signed char
using	uint8 = unsigned char
using	int16 = signed short
using	uint16 = unsigned short
using	int32 = signed int
using	uint32 = unsigned int
using	int64 = long long
using	uint64 = unsigned long long
using	pointer_sized_int = int
using	pointer_sized_uint = unsigned int
template<typename A, typename B>
using	DisableIfSameOrDerived = typename std::enable_if_t<! std::is_base_of<A, std::remove_reference_t<B>>::value>
template<typename CFType>
using	CFUniquePtr = std::unique_ptr<typename std::remove_pointer<CFType>::type, CFObjectDeleter<CFType>>
template<typename NSType>
using	NSUniquePtr = std::unique_ptr<NSType, NSObjectDeleter>
using	juce_socklen_t = socklen_t
using	juce_recvsend_size_t = socklen_t
using	SocketHandle = int
using	juce_wchar = wchar_t
using	CharPointer_wchar_t = CharPointer_UTF32
using	ScopedLock = CriticalSection::ScopedLockType
using	ScopedUnlock = CriticalSection::ScopedUnlockType
using	ScopedTryLock = CriticalSection::ScopedTryLockType
using	MessageCallbackFunction = void* (void* userData)
using	CheckEventBlockedByModalComps = bool (*)(const MSG&)
using	SettingChangeCallbackFunc = void (*)(void)
using	GetTypefaceForFont = Typeface::Ptr (*)(const Font&)
typedef HWND__ *	HWND
using	CommandID = int
using	ViewportDragPosition = AnimatedPosition<AnimatedPositionBehaviours::ContinuousWithMomentum>
typedef HANDLE	HTOUCHINPUT
typedef HANDLE	HGESTUREINFO
typedef DWORD	POINTER_INPUT_TYPE
typedef UINT32	POINTER_FLAGS
typedef UINT32	PEN_FLAGS
typedef UINT32	PEN_MASK
typedef UINT32	TOUCH_FLAGS
typedef UINT32	TOUCH_MASK
typedef HANDLE	DPI_AWARENESS_CONTEXT
using	RegisterTouchWindowFunc = BOOL (WINAPI*) (HWND, ULONG)
using	GetTouchInputInfoFunc = BOOL (WINAPI*) (HTOUCHINPUT, UINT, TOUCHINPUT*, int)
using	CloseTouchInputHandleFunc = BOOL (WINAPI*) (HTOUCHINPUT)
using	GetGestureInfoFunc = BOOL (WINAPI*) (HGESTUREINFO, GESTUREINFO*)
using	GetPointerTypeFunc = BOOL (WINAPI*) (UINT32, POINTER_INPUT_TYPE*)
using	GetPointerTouchInfoFunc = BOOL (WINAPI*) (UINT32, POINTER_TOUCH_INFO*)
using	GetPointerPenInfoFunc = BOOL (WINAPI*) (UINT32, POINTER_PEN_INFO*)
using	SetProcessDPIAwareFunc = BOOL (WINAPI*) ()
using	SetProcessDPIAwarenessContextFunc = BOOL (WINAPI*) (DPI_AWARENESS_CONTEXT)
using	SetProcessDPIAwarenessFunc = HRESULT (WINAPI*) (DPI_Awareness)
using	SetThreadDPIAwarenessContextFunc = DPI_AWARENESS_CONTEXT (WINAPI*) (DPI_AWARENESS_CONTEXT)
using	GetDPIForWindowFunc = UINT (WINAPI*) (HWND)
using	GetDPIForMonitorFunc = HRESULT (WINAPI*) (HMONITOR, Monitor_DPI_Type, UINT*, UINT*)
using	GetSystemMetricsForDpiFunc = int (WINAPI*) (int, UINT)
using	GetProcessDPIAwarenessFunc = HRESULT (WINAPI*) (HANDLE, DPI_Awareness*)
using	GetWindowDPIAwarenessContextFunc = DPI_AWARENESS_CONTEXT (WINAPI*) (HWND)
using	GetThreadDPIAwarenessContextFunc = DPI_AWARENESS_CONTEXT (WINAPI*) ()
using	GetAwarenessFromDpiAwarenessContextFunc = DPI_Awareness (WINAPI*) (DPI_AWARENESS_CONTEXT)
using	EnableNonClientDPIScalingFunc = BOOL (WINAPI*) (HWND)
typedef HSTRING_PRIVATE *	HSTRING
using	TaskDialogIndirectFunc = HRESULT (WINAPI*) (const TASKDIALOGCONFIG*, INT*, INT*, BOOL*)

Enumerations
enum class	WASAPIDeviceMode { shared , exclusive , sharedLowLatency }
enum	EDataFlow { eRender = 0 , eCapture = (eRender + 1) , eAll = (eCapture + 1) }
enum	{ DEVICE_STATE_ACTIVE = 1 }
enum	{ AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY = 1 , AUDCLNT_BUFFERFLAGS_SILENT = 2 }
enum	ERole { eConsole = 0 , eMultimedia = (eConsole + 1) , eCommunications = (eMultimedia + 1) }
enum	AVRT_PRIORITY { AVRT_PRIORITY_LOW = -1 , AVRT_PRIORITY_NORMAL , AVRT_PRIORITY_HIGH , AVRT_PRIORITY_CRITICAL }
enum	AUDCLNT_SHAREMODE { AUDCLNT_SHAREMODE_SHARED , AUDCLNT_SHAREMODE_EXCLUSIVE }
enum	AUDIO_STREAM_CATEGORY {   AudioCategory_Other = 0 , AudioCategory_ForegroundOnlyMedia , AudioCategory_BackgroundCapableMedia , AudioCategory_Communications ,   AudioCategory_Alerts , AudioCategory_SoundEffects , AudioCategory_GameEffects , AudioCategory_GameMedia ,   AudioCategory_GameChat , AudioCategory_Speech , AudioCategory_Movie , AudioCategory_Media }
enum	AudioSessionDisconnectReason {   DisconnectReasonDeviceRemoval = 0 , DisconnectReasonServerShutdown = 1 , DisconnectReasonFormatChanged = 2 , DisconnectReasonSessionLogoff = 3 ,   DisconnectReasonSessionDisconnected = 4 , DisconnectReasonExclusiveModeOverride = 5 }
enum	AudioSessionState { AudioSessionStateInactive = 0 , AudioSessionStateActive = 1 , AudioSessionStateExpired = 2 }
enum	{ kAudioUnitProperty_SupportsMPE = 58 }
enum	VariantStreamMarkers {   varMarker_Int = 1 , varMarker_BoolTrue = 2 , varMarker_BoolFalse = 3 , varMarker_Double = 4 ,   varMarker_String = 5 , varMarker_Int64 = 6 , varMarker_Array = 7 , varMarker_Binary = 8 ,   varMarker_Undefined = 9 }
enum	{ U_ISOFS_SUPER_MAGIC = 0x9660 , U_MSDOS_SUPER_MAGIC = 0x4d44 , U_NFS_SUPER_MAGIC = 0x6969 , U_SMB_SUPER_MAGIC = 0x517B }
enum	{ magicCoordWorkerConnectionHeader = 0x712baf04 }
enum	{ specialMessageSize = 8 , defaultTimeoutMs = 8000 }
enum	NotificationType { dontSendNotification = 0 , sendNotification = 1 , sendNotificationSync , sendNotificationAsync }
enum class	AccessibilityActionType { press , toggle , focus , showMenu }
enum class	AccessibilityEvent {   valueChanged , titleChanged , structureChanged , textSelectionChanged ,   textChanged , rowSelectionChanged }
enum class	AccessibilityRole {   button , toggleButton , radioButton , comboBox ,   image , slider , label , staticText ,   editableText , menuItem , menuBar , popupMenu ,   table , tableHeader , column , row ,   cell , hyperlink , list , listItem ,   tree , treeItem , progressBar , group ,   dialogWindow , window , scrollBar , tooltip ,   splashScreen , ignored , unspecified }
enum class	InternalAccessibilityEvent {   elementCreated , elementDestroyed , elementMovedOrResized , focusChanged ,   windowOpened , windowClosed }
enum	{ clickMessageId = 0x2f3f4f99 }
enum	{ WM_TOUCH = 0x0240 , TOUCHEVENTF_MOVE = 0x0001 , TOUCHEVENTF_DOWN = 0x0002 , TOUCHEVENTF_UP = 0x0004 }
enum	{   WM_NCPOINTERUPDATE = 0x241 , WM_NCPOINTERDOWN = 0x242 , WM_NCPOINTERUP = 0x243 , WM_POINTERUPDATE = 0x245 ,   WM_POINTERDOWN = 0x246 , WM_POINTERUP = 0x247 , WM_POINTERENTER = 0x249 , WM_POINTERLEAVE = 0x24A ,   WM_POINTERACTIVATE = 0x24B , WM_POINTERCAPTURECHANGED = 0x24C , WM_TOUCHHITTESTING = 0x24D , WM_POINTERWHEEL = 0x24E ,   WM_POINTERHWHEEL = 0x24F , WM_POINTERHITTEST = 0x250 }
enum	{ PT_TOUCH = 0x00000002 , PT_PEN = 0x00000003 }
enum	POINTER_BUTTON_CHANGE_TYPE {   POINTER_CHANGE_NONE , POINTER_CHANGE_FIRSTBUTTON_DOWN , POINTER_CHANGE_FIRSTBUTTON_UP , POINTER_CHANGE_SECONDBUTTON_DOWN ,   POINTER_CHANGE_SECONDBUTTON_UP , POINTER_CHANGE_THIRDBUTTON_DOWN , POINTER_CHANGE_THIRDBUTTON_UP , POINTER_CHANGE_FOURTHBUTTON_DOWN ,   POINTER_CHANGE_FOURTHBUTTON_UP , POINTER_CHANGE_FIFTHBUTTON_DOWN , POINTER_CHANGE_FIFTHBUTTON_UP }
enum	{   PEN_MASK_NONE = 0x00000000 , PEN_MASK_PRESSURE = 0x00000001 , PEN_MASK_ROTATION = 0x00000002 , PEN_MASK_TILT_X = 0x00000004 ,   PEN_MASK_TILT_Y = 0x00000008 }
enum	{ TOUCH_MASK_NONE = 0x00000000 , TOUCH_MASK_CONTACTAREA = 0x00000001 , TOUCH_MASK_ORIENTATION = 0x00000002 , TOUCH_MASK_PRESSURE = 0x00000004 }
enum	{   POINTER_FLAG_NONE = 0x00000000 , POINTER_FLAG_NEW = 0x00000001 , POINTER_FLAG_INRANGE = 0x00000002 , POINTER_FLAG_INCONTACT = 0x00000004 ,   POINTER_FLAG_FIRSTBUTTON = 0x00000010 , POINTER_FLAG_SECONDBUTTON = 0x00000020 , POINTER_FLAG_THIRDBUTTON = 0x00000040 , POINTER_FLAG_FOURTHBUTTON = 0x00000080 ,   POINTER_FLAG_FIFTHBUTTON = 0x00000100 , POINTER_FLAG_PRIMARY = 0x00002000 , POINTER_FLAG_CONFIDENCE = 0x00004000 , POINTER_FLAG_CANCELED = 0x00008000 ,   POINTER_FLAG_DOWN = 0x00010000 , POINTER_FLAG_UPDATE = 0x00020000 , POINTER_FLAG_UP = 0x00040000 , POINTER_FLAG_WHEEL = 0x00080000 ,   POINTER_FLAG_HWHEEL = 0x00100000 , POINTER_FLAG_CAPTURECHANGED = 0x00200000 , POINTER_FLAG_HASTRANSFORM = 0x00400000 }
enum	Monitor_DPI_Type { MDT_Effective_DPI = 0 , MDT_Angular_DPI = 1 , MDT_Raw_DPI = 2 , MDT_Default = MDT_Effective_DPI }
enum	DPI_Awareness { DPI_Awareness_Invalid = -1 , DPI_Awareness_Unaware = 0 , DPI_Awareness_System_Aware = 1 , DPI_Awareness_Per_Monitor_Aware = 2 }
enum	{ KeyPressEventType = 2 }
enum class	Async { no , yes }
enum class	MessageBoxIconType { NoIcon , QuestionIcon , WarningIcon , InfoIcon }
enum	{ maxXEmbedVersionToSupport = 0 }
enum	{ XEMBED_MAPPED = (1<<0) }
enum	{   XEMBED_EMBEDDED_NOTIFY = 0 , XEMBED_WINDOW_ACTIVATE = 1 , XEMBED_WINDOW_DEACTIVATE = 2 , XEMBED_REQUEST_FOCUS = 3 ,   XEMBED_FOCUS_IN = 4 , XEMBED_FOCUS_OUT = 5 , XEMBED_FOCUS_NEXT = 6 , XEMBED_FOCUS_PREV = 7 ,   XEMBED_MODALITY_ON = 10 , XEMBED_MODALITY_OFF = 11 , XEMBED_REGISTER_ACCELERATOR = 12 , XEMBED_UNREGISTER_ACCELERATOR = 13 ,   XEMBED_ACTIVATE_ACCELERATOR = 14 }
enum	{ XEMBED_FOCUS_CURRENT = 0 , XEMBED_FOCUS_FIRST = 1 , XEMBED_FOCUS_LAST = 2 }

Functions
bool	dispatchNextMessageOnSystemQueue (bool returnIfNoPendingMessages)
template<int k>
static float	calcCoefficient (float input, float offset) noexcept
template<typename Setup>
static auto	getSetupInfo (Setup &s, bool isInput)
static auto	tie (const AudioDeviceManager::AudioDeviceSetup &s)
static void	addIfNotNull (OwnedArray< AudioIODeviceType > &list, AudioIODeviceType *const device)
static bool	deviceListContains (AudioIODeviceType *type, bool isInput, const String &name)
static void	updateSetupChannels (AudioDeviceManager::AudioDeviceSetup &setup, int defaultNumIns, int defaultNumOuts)
static AudioIODeviceType *	createAudioIODeviceType_ALSA_Soundcards ()
static AudioIODeviceType *	createAudioIODeviceType_ALSA_PCMDevices ()
static void *	juce_loadJackFunction (const char *const name)
	JUCE_DECL_JACK_FUNCTION (jack_client_t *, jack_client_open,(const char *client_name, jack_options_t options, jack_status_t *status,...),(client_name, options, status)) JUCE_DECL_JACK_FUNCTION(int
jack_client_t client	JUCE_DECL_JACK_FUNCTION (int, jack_activate,(jack_client_t *client),(client)) JUCE_DECL_JACK_FUNCTION(int
jack_client_t client jack_client_t client	JUCE_DECL_JACK_FUNCTION (jack_nframes_t, jack_get_buffer_size,(jack_client_t *client),(client)) JUCE_DECL_JACK_FUNCTION(jack_nframes_t
jack_client_t client jack_client_t client jack_client_t client	JUCE_DECL_VOID_JACK_FUNCTION (jack_on_shutdown,(jack_client_t *client, void(*function)(void *arg), void *arg),(client, function, arg)) JUCE_DECL_VOID_JACK_FUNCTION(jack_on_info_shutdown
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg	JUCE_DECL_JACK_FUNCTION (void *, jack_port_get_buffer,(jack_port_t *port, jack_nframes_t nframes),(port, nframes)) JUCE_DECL_JACK_FUNCTION(jack_nframes_t
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port	JUCE_DECL_JACK_FUNCTION (jack_port_t *, jack_port_register,(jack_client_t *client, const char *port_name, const char *port_type, unsigned long flags, unsigned long buffer_size),(client, port_name, port_type, flags, buffer_size)) JUCE_DECL_VOID_JACK_FUNCTION(jack_set_error_function
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func	JUCE_DECL_JACK_FUNCTION (int, jack_set_process_callback,(jack_client_t *client, JackProcessCallback process_callback, void *arg),(client, process_callback, arg)) JUCE_DECL_JACK_FUNCTION(const char **
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags	JUCE_DECL_JACK_FUNCTION (int, jack_connect,(jack_client_t *client, const char *source_port, const char *destination_port),(client, source_port, destination_port)) JUCE_DECL_JACK_FUNCTION(const char *
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port	JUCE_DECL_JACK_FUNCTION (void *, jack_set_port_connect_callback,(jack_client_t *client, JackPortConnectCallback connect_callback, void *arg),(client, connect_callback, arg)) JUCE_DECL_JACK_FUNCTION(jack_port_t *
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port jack_client_t jack_port_id_t port_id	JUCE_DECL_JACK_FUNCTION (int, jack_port_connected,(const jack_port_t *port),(port)) JUCE_DECL_JACK_FUNCTION(int
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port jack_client_t jack_port_id_t port_id const jack_port_t const char port_name	JUCE_DECL_JACK_FUNCTION (int, jack_set_xrun_callback,(jack_client_t *client, JackXRunCallback xrun_callback, void *arg),(client, xrun_callback, arg)) JUCE_DECL_JACK_FUNCTION(int
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port jack_client_t jack_port_id_t port_id const jack_port_t const char port_name const jack_port_t port	JUCE_DECL_JACK_FUNCTION (jack_port_t *, jack_port_by_name,(jack_client_t *client, const char *name),(client, name)) JUCE_DECL_VOID_JACK_FUNCTION(jack_free
static void	sendASIODeviceChangeToListeners (ASIOAudioIODeviceType *)
RTL_OSVERSIONINFOW	getWindowsVersionInfo ()
static int	findDefaultDeviceIndex (const Array< MidiDeviceInfo > &available, const MidiDeviceInfo &defaultDevice)
	JUCE_IUNKNOWNCLASS (IPropertyStore, "886d8eeb-8cf2-4446-8d02-cdba1dbdcf99")
	JUCE_IUNKNOWNCLASS (IMMDevice, "D666063F-1587-4E43-81F1-B948E807363F")
	JUCE_IUNKNOWNCLASS (IMMEndpoint, "1BE09788-6894-4089-8586-9A2A6C265AC5")
	JUCE_IUNKNOWNCLASS (IMMNotificationClient, "7991EEC9-7E89-4D85-8390-6C703CEC60C0")
	JUCE_IUNKNOWNCLASS (IMMDeviceEnumerator, "A95664D2-9614-4F35-A746-DE8DB63617E6")
	JUCE_COMCLASS (MMDeviceEnumerator, "BCDE0395-E52F-467C-8E3D-C4579291692E")
	JUCE_IUNKNOWNCLASS (IAudioClient, "1CB9AD4C-DBFA-4c32-B178-C2F568A703B2")
JUCE_COMCLASS(IAudioClient2, "726778CD-F60A-4eda-82DE-E47610CD78AA") JUCE_COMCLASS(IAudioClient3, "1CB9AD4C-DBFA-4c32-B178-C2F568A703B2")	JUCE_IUNKNOWNCLASS (IAudioCaptureClient, "C8ADBD64-E71E-48a0-A4DE-185C395CD317")
	JUCE_IUNKNOWNCLASS (IAudioRenderClient, "F294ACFC-3146-4483-A7BF-ADDCA7C260E2")
	JUCE_IUNKNOWNCLASS (IAudioEndpointVolume, "5CDF2C82-841E-4546-9722-0CF74078229A")
	JUCE_IUNKNOWNCLASS (IAudioSessionEvents, "24918ACC-64B3-37C1-8CA9-74A66E9957A8")
	JUCE_IUNKNOWNCLASS (IAudioSessionControl, "F4B1A599-7266-4319-A8CA-E70ACB11E8CD")
static auto	toMap (const StringPairArray &array)
static auto	getValueWithDefault (const StringMap &m, const String &key, const String &fallback={})
static void	convertFixedToFloat (int *const *channels, int numChannels, int numSamples)
static bool	readChannels (AudioFormatReader &reader, int **chans, AudioBuffer< float > *buffer, int startSample, int numSamples, int64 readerStartSample, int numTargetChannels, bool convertToFloat)
static void	convertFloatsToInts (int *dest, const float *src, int numSamples) noexcept
template<typename Obj, typename Member, typename... Ts>
constexpr Obj	makeARASizedStruct (Member Obj::*member, Ts &&... ts)
bool	doUIDsMatch (const Steinberg::TUID a, const Steinberg::TUID b) noexcept
template<typename ToTest, typename CommonClassType, typename SourceClassType>
InterfaceResultWithDeferredAddRef	testFor (ToTest &toTest, const Steinberg::TUID targetIID, SharedBase< CommonClassType, SourceClassType >)
template<typename ToTest, typename ClassType>
InterfaceResultWithDeferredAddRef	testFor (ToTest &toTest, const Steinberg::TUID targetIID, UniqueBase< ClassType >)
template<typename ToTest>
InterfaceResultWithDeferredAddRef	testForMultiple (ToTest &, const Steinberg::TUID)
template<typename ToTest, typename Head, typename... Tail>
InterfaceResultWithDeferredAddRef	testForMultiple (ToTest &toTest, const Steinberg::TUID targetIID, Head head, Tail... tail)
juce::String	toString (const Steinberg::char8 *string) noexcept
juce::String	toString (const Steinberg::char16 *string) noexcept
juce::String	toString (const Steinberg::UString128 &string) noexcept
juce::String	toString (const Steinberg::UString256 &string) noexcept
Steinberg::Vst::TChar *	toString (const juce::String &source) noexcept
void	toString128 (Steinberg::Vst::String128 result, const char *source)
void	toString128 (Steinberg::Vst::String128 result, const juce::String &source)
static Steinberg::Vst::SpeakerArrangement	getArrangementForBus (Steinberg::Vst::IAudioProcessor *processor, bool isInput, int busIndex)
static Steinberg::Vst::Speaker	getSpeakerType (const AudioChannelSet &set, AudioChannelSet::ChannelType type) noexcept
static AudioChannelSet::ChannelType	getChannelType (Steinberg::Vst::SpeakerArrangement arr, Steinberg::Vst::Speaker type) noexcept
bool	isLayoutTableValid ()
static Array< AudioChannelSet::ChannelType >	getSpeakerOrder (Steinberg::Vst::SpeakerArrangement arr)
static Steinberg::Vst::SpeakerArrangement	getVst3SpeakerArrangement (const AudioChannelSet &channels) noexcept
AudioChannelSet	getChannelSetForSpeakerArrangement (Steinberg::Vst::SpeakerArrangement arr) noexcept
auto &	getAudioBusPointer (detail::Tag< float >, Steinberg::Vst::AudioBusBuffers &data)
auto &	getAudioBusPointer (detail::Tag< double >, Steinberg::Vst::AudioBusBuffers &data)
static int	countUsedClientChannels (const std::vector< DynamicChannelMapping > &inputMap, const std::vector< DynamicChannelMapping > &outputMap)
template<typename FloatType>
static int	countValidBuses (Steinberg::Vst::AudioBusBuffers *buffers, int32 num)
template<typename FloatType, typename Iterator>
static bool	validateLayouts (Iterator first, Iterator last, const std::vector< DynamicChannelMapping > &map)
template<typename Callback>
void	callOnMessageThread (Callback &&callback)
static String	getChannelName (const OwnedArray< AudioProcessor::Bus > &buses, int index)
static bool	isStereoPair (const OwnedArray< AudioProcessor::Bus > &buses, int index)
static void	updateOnMessageThread (AsyncUpdater &updater)
template<typename FloatType, typename SequenceType>
static void	processBlockForBuffer (AudioBuffer< FloatType > &buffer, MidiBuffer &midiMessages, AudioProcessorGraph &graph, std::unique_ptr< SequenceType > &renderSequence, std::atomic< bool > &isPrepared)
template<typename FloatType, typename SequenceType>
static void	processIOBlock (AudioProcessorGraph::AudioGraphIOProcessor &io, SequenceType &sequence, AudioBuffer< FloatType > &buffer, MidiBuffer &midiMessages)
static String	getPluginDescSuffix (const PluginDescription &d, int uid)
static StringArray	readDeadMansPedalFile (const File &file)
static bool	canShowFolderForPlugin (KnownPluginList &list, int index)
static void	showFolderForPlugin (KnownPluginList &list, int index)
template<typename Attachment, typename Control>
std::unique_ptr< Attachment >	makeAttachment (const AudioProcessorValueTreeState &stateToUse, const String &parameterID, Control &control)
static void	removeScaleFactorListenerFromAllPeers (ComponentPeer::ScaleFactorListener &listener)
Image JUCE_API	getIconFromApplication (const String &, const int)
template<class ElementType, class ElementComparator>
static void	sortArray (ElementComparator &comparator, ElementType *const array, int firstElement, int lastElement, const bool retainOrderOfEquivalentItems)
template<class ElementType, class ElementComparator>
static int	findInsertIndexInSortedArray (ElementComparator &comparator, ElementType *const array, const ElementType newElement, int firstElement, int lastElement)
static const var &	getNullVarRef () noexcept
template<typename Value>
JUCE_END_IGNORE_WARNINGS_MSVC Optional< std::decay_t< Value > >	makeOptional (Value &&v)
template<class T, class U>
bool	operator== (const Optional< T > &lhs, const Optional< U > &rhs)
template<class T, class U>
bool	operator!= (const Optional< T > &lhs, const Optional< U > &rhs)
template<class T, class U>
bool	operator< (const Optional< T > &lhs, const Optional< U > &rhs)
template<class T, class U>
bool	operator<= (const Optional< T > &lhs, const Optional< U > &rhs)
template<class T, class U>
bool	operator> (const Optional< T > &lhs, const Optional< U > &rhs)
template<class T, class U>
bool	operator>= (const Optional< T > &lhs, const Optional< U > &rhs)
template<class T>
bool	operator== (const Optional< T > &opt, Nullopt) noexcept
template<class T>
bool	operator== (Nullopt, const Optional< T > &opt) noexcept
template<class T>
bool	operator!= (const Optional< T > &opt, Nullopt) noexcept
template<class T>
bool	operator!= (Nullopt, const Optional< T > &opt) noexcept
template<class T>
bool	operator< (const Optional< T > &, Nullopt) noexcept
template<class T>
bool	operator< (Nullopt, const Optional< T > &opt) noexcept
template<class T>
bool	operator<= (const Optional< T > &opt, Nullopt) noexcept
template<class T>
bool	operator<= (Nullopt, const Optional< T > &) noexcept
template<class T>
bool	operator> (const Optional< T > &opt, Nullopt) noexcept
template<class T>
bool	operator> (Nullopt, const Optional< T > &) noexcept
template<class T>
bool	operator>= (const Optional< T > &, Nullopt) noexcept
template<class T>
bool	operator>= (Nullopt, const Optional< T > &opt) noexcept
template<class T, class U>
bool	operator== (const Optional< T > &opt, const U &value)
template<class T, class U>
bool	operator== (const T &value, const Optional< U > &opt)
template<class T, class U>
bool	operator!= (const Optional< T > &opt, const U &value)
template<class T, class U>
bool	operator!= (const T &value, const Optional< U > &opt)
template<class T, class U>
bool	operator< (const Optional< T > &opt, const U &value)
template<class T, class U>
bool	operator< (const T &value, const Optional< U > &opt)
template<class T, class U>
bool	operator<= (const Optional< T > &opt, const U &value)
template<class T, class U>
bool	operator<= (const T &value, const Optional< U > &opt)
template<class T, class U>
bool	operator> (const Optional< T > &opt, const U &value)
template<class T, class U>
bool	operator> (const T &value, const Optional< U > &opt)
template<class T, class U>
bool	operator>= (const Optional< T > &opt, const U &value)
template<class T, class U>
bool	operator>= (const T &value, const Optional< U > &opt)
static void	swap (ThrowOnMoveOrSwap &, ThrowOnMoveOrSwap &)
bool	canCompare (const var &v1, const var &v2)
static int	compare (const var &v1, const var &v2)
bool	operator== (const var &v1, const var &v2)
bool	operator!= (const var &v1, const var &v2)
bool	operator< (const var &v1, const var &v2)
bool	operator> (const var &v1, const var &v2)
bool	operator<= (const var &v1, const var &v2)
bool	operator>= (const var &v1, const var &v2)
bool	operator== (const var &v1, const String &v2)
bool	operator!= (const var &v1, const String &v2)
bool	operator== (const var &v1, const char *v2)
bool	operator!= (const var &v1, const char *v2)
static StringArray	getMatches (const String &toMatch, const char *MimeTypeTableEntry::*matchField, const char *MimeTypeTableEntry::*returnField)
static String	removeEllipsis (const String &path)
static String	normaliseSeparators (const String &path)
static int	compareFilenames (const String &name1, const String &name2) noexcept
static int	countNumberOfSeparators (String::CharPointerType s)
int64	juce_fileSetPosition (void *handle, int64 pos)
const DirectoryEntry &	operator* (const DirectoryEntry &e) noexcept
RangedDirectoryIterator	begin (const RangedDirectoryIterator &it)
RangedDirectoryIterator	end (const RangedDirectoryIterator &)
static File	createTempFile (const File &parentDirectory, String name, const String &suffix, int optionFlags)
static void	parseWildcard (const String &pattern, StringArray &result)
static bool	matchWildcard (const File &file, const StringArray &wildcards)
JUCE_API bool JUCE_CALLTYPE	juce_isRunningUnderDebugger () noexcept
JUCE_API void JUCE_CALLTYPE	logAssertion (const char *file, int line) noexcept
int	findHighestSetBit (uint32 n) noexcept
static BigInteger	simpleGCD (BigInteger *m, BigInteger *n)
OutputStream &JUCE_CALLTYPE	operator<< (OutputStream &stream, const BigInteger &value)
void	writeLittleEndianBitsInBuffer (void *buffer, uint32 startBit, uint32 numBits, uint32 value) noexcept
uint32	readLittleEndianBitsInBuffer (const void *buffer, uint32 startBit, uint32 numBits) noexcept
template<typename Type>
constexpr Type	jmax (Type a, Type b)
template<typename Type>
constexpr Type	jmax (Type a, Type b, Type c)
template<typename Type>
constexpr Type	jmax (Type a, Type b, Type c, Type d)
template<typename Type>
constexpr Type	jmin (Type a, Type b)
template<typename Type>
constexpr Type	jmin (Type a, Type b, Type c)
template<typename Type>
constexpr Type	jmin (Type a, Type b, Type c, Type d)
template<typename Type>
constexpr Type	jmap (Type value0To1, Type targetRangeMin, Type targetRangeMax)
template<typename Type>
Type	jmap (Type sourceValue, Type sourceRangeMin, Type sourceRangeMax, Type targetRangeMin, Type targetRangeMax)
template<typename Type>
Type	mapToLog10 (Type value0To1, Type logRangeMin, Type logRangeMax)
template<typename Type>
Type	mapFromLog10 (Type valueInLogRange, Type logRangeMin, Type logRangeMax)
template<typename Type, typename Size>
Type	findMinimum (const Type *data, Size numValues)
template<typename Type, typename Size>
Type	findMaximum (const Type *values, Size numValues)
template<typename Type>
void	findMinAndMax (const Type *values, int numValues, Type &lowest, Type &highest)
template<typename Type>
Type	jlimit (Type lowerLimit, Type upperLimit, Type valueToConstrain) noexcept
template<typename Type1, typename Type2>
bool	isPositiveAndBelow (Type1 valueToTest, Type2 upperLimit) noexcept
template<typename Type>
bool	isPositiveAndBelow (int valueToTest, Type upperLimit) noexcept
template<typename Type1, typename Type2>
bool	isPositiveAndNotGreaterThan (Type1 valueToTest, Type2 upperLimit) noexcept
template<typename Type>
bool	isPositiveAndNotGreaterThan (int valueToTest, Type upperLimit) noexcept
template<typename Type>
bool	isWithin (Type a, Type b, Type tolerance) noexcept
template<typename Type>
bool	approximatelyEqual (Type a, Type b) noexcept
template<typename... Types>
void	ignoreUnused (Types &&...) noexcept
template<typename Type, size_t N>
constexpr int	numElementsInArray (Type(&)[N]) noexcept
template<typename Type>
Type	juce_hypot (Type a, Type b) noexcept
template<>
float	juce_hypot (float a, float b) noexcept
template<typename FloatType>
constexpr FloatType	degreesToRadians (FloatType degrees) noexcept
template<typename FloatType>
constexpr FloatType	radiansToDegrees (FloatType radians) noexcept
template<typename NumericType>
bool	juce_isfinite (NumericType) noexcept
template<>
bool	juce_isfinite (float value) noexcept
template<>
bool	juce_isfinite (double value) noexcept
template<typename FloatType>
int	roundToInt (const FloatType value) noexcept
int	roundToInt (int value) noexcept
int	roundToIntAccurate (double value) noexcept
template<typename FloatType>
unsigned int	truncatePositiveToUnsignedInt (FloatType value) noexcept
template<typename IntegerType>
constexpr bool	isPowerOfTwo (IntegerType value)
int	nextPowerOfTwo (int n) noexcept
int	countNumberOfBits (uint32 n) noexcept
int	countNumberOfBits (uint64 n) noexcept
template<typename IntegerType>
IntegerType	negativeAwareModulo (IntegerType dividend, const IntegerType divisor) noexcept
template<typename NumericType>
constexpr NumericType	square (NumericType n) noexcept
int	roundDoubleToInt (double value) noexcept
int	roundFloatToInt (float value) noexcept
int64	abs64 (int64 n) noexcept
void	zeromem (void *memory, size_t numBytes) noexcept
template<typename Type>
void	zerostruct (Type &structure) noexcept
template<typename Type>
void	deleteAndZero (Type &pointer)
template<typename Type, typename IntegerType>
Type *	snapPointerToAlignment (Type *basePointer, IntegerType alignmentBytes) noexcept
template<typename Type1, typename Type2>
int	getAddressDifference (Type1 *pointer1, Type2 *pointer2) noexcept
template<class Type>
Type *	createCopyIfNotNull (const Type *objectToCopy)
template<typename Type>
Type	readUnaligned (const void *srcPtr) noexcept
template<typename Type>
void	writeUnaligned (void *dstPtr, Type value) noexcept
template<typename Type, typename std::enable_if< std::is_pointer< Type >::value, int >::type = 0>
Type	unalignedPointerCast (void *ptr) noexcept
template<typename Type, typename std::enable_if< std::is_pointer< Type >::value, int >::type = 0>
Type	unalignedPointerCast (const void *ptr) noexcept
template<typename Type, typename IntegerType>
Type *	addBytesToPointer (Type *basePointer, IntegerType bytes) noexcept
template<typename Type, typename IntegerType>
const Type *	addBytesToPointer (const Type *basePointer, IntegerType bytes) noexcept
template<typename T>
std::unique_ptr< T >	rawToUniquePtr (T *ptr)
template<typename Type>
bool	operator== (const Type *object1, const ReferenceCountedObjectPtr< Type > &object2) noexcept
template<typename Type>
bool	operator!= (const Type *object1, const ReferenceCountedObjectPtr< Type > &object2) noexcept
template<typename ObjectType1, typename ObjectType2>
bool	operator== (ObjectType1 *pointer1, const ScopedPointer< ObjectType2 > &pointer2) noexcept
template<typename ObjectType1, typename ObjectType2>
bool	operator!= (ObjectType1 *pointer1, const ScopedPointer< ObjectType2 > &pointer2) noexcept
template<typename ObjectType1, typename ObjectType2>
bool	operator== (const ScopedPointer< ObjectType1 > &pointer1, ObjectType2 *pointer2) noexcept
template<typename ObjectType1, typename ObjectType2>
bool	operator!= (const ScopedPointer< ObjectType1 > &pointer1, ObjectType2 *pointer2) noexcept
template<typename ObjectType1, typename ObjectType2>
bool	operator== (const ScopedPointer< ObjectType1 > &pointer1, const ScopedPointer< ObjectType2 > &pointer2) noexcept
template<typename ObjectType1, typename ObjectType2>
bool	operator!= (const ScopedPointer< ObjectType1 > &pointer1, const ScopedPointer< ObjectType2 > &pointer2) noexcept
template<class ObjectType>
bool	operator== (decltype(nullptr), const ScopedPointer< ObjectType > &pointer) noexcept
template<class ObjectType>
bool	operator!= (decltype(nullptr), const ScopedPointer< ObjectType > &pointer) noexcept
template<class ObjectType>
bool	operator== (const ScopedPointer< ObjectType > &pointer, decltype(nullptr)) noexcept
template<class ObjectType>
bool	operator!= (const ScopedPointer< ObjectType > &pointer, decltype(nullptr)) noexcept
template<typename Type>
void	deleteAndZero (ScopedPointer< Type > &)
static File	resolveFilename (const String &name)
static File	checkFileExists (const File &f)
static File	checkFolderExists (const File &f)
static File	resolveFilenameForOption (const ArgumentList &args, StringRef option, const String &filename)
static bool	isShortOptionFormat (StringRef s)
static bool	isLongOptionFormat (StringRef s)
static bool	isOptionFormat (StringRef s)
static String	getExeNameAndArgs (const ArgumentList &args, const ConsoleApplication::Command &command)
static void	printCommandDescription (const ArgumentList &args, const ConsoleApplication::Command &command, int descriptionIndent)
template<typename Object, typename OtherObject, typename Member>
Object	withMember (Object copy, Member OtherObject::*member, Member &&value)
static File	resolveXDGFolder (const char *const type, const char *const fallbackFolder)
static bool	isFileExecutable (const String &filename)
static String	getCpuInfo (const char *key)
static String	getLocaleValue (nl_item key)
uint32	juce_millisecondsSinceStartup () noexcept
static bool	swapUserAndEffectiveUser ()
Range< int >	nsRangeToJuce (NSRange range)
NSRange	juceRangeToNS (Range< int > range)
String	nsStringToJuce (NSString *s)
NSString *	juceStringToNS (const String &s)
NSString *	nsStringLiteral (const char *const s) noexcept
NSString *	nsEmptyString () noexcept
NSURL *	createNSURLFromFile (const String &f)
NSURL *	createNSURLFromFile (const File &f)
NSArray *	createNSArrayFromStringArray (const StringArray &strings)
NSArray *	varArrayToNSArray (const var &varToParse)
NSDictionary *	varObjectToNSDictionary (const var &varToParse)
var	nsObjectToVar (NSObject *array)
var	nsDictionaryToVar (NSDictionary *dictionary)
var	nsArrayToVar (NSArray *array)
template<typename SuperType, typename ReturnType, typename... Params>
ReturnType	ObjCMsgSendSuper (id self, SEL sel, Params... params)
template<typename Type>
Type	getIvar (id self, const char *name)
template<typename Class>
NSObject *	createNSObjectFromJuceClass (Class *obj)
template<typename Class>
Class *	getJuceClassFromNSObject (NSObject *obj)
template<typename ReturnT, class Class, typename... Params>
ReturnT(^)(Params...)	CreateObjCBlock (Class *object, ReturnT(Class::*fn)(Params...))
int	juce_siginterrupt (int sig, int flag)
static bool	hasEffectiveRootFilePermissions ()
static bool	setFileModeFlags (const String &fullPath, mode_t flags, bool shouldSet) noexcept
File	juce_getExecutableFile ()
void	juce_runSystemCommand (const String &)
String	juce_getOutputFromCommand (const String &)
static void *	threadEntryProc (void *userData)
GUID	uuidFromString (const char *s) noexcept
void *	getUser32Function (const char *)
static String	readWindowsLnkFile (File lnkFile, bool wantsAbsolutePath)
static String	readWindowsShortcutOrLink (const File &shortcut, bool wantsAbsolutePath)
static bool	deleteKeyNonRecursive (const String &regKeyPath, WindowsRegistry::WoW64Mode mode)
static void	callCPUID (int result[4], int infoType)
static int	findNumberOfPhysicalCores () noexcept
static int64	juce_getClockCycleCounter () noexcept
static String	getLocaleValue (LCID locale, LCTYPE key, const char *defaultValue)
static unsigned int STDMETHODCALLTYPE	threadEntryProc (void *userData)
void	juce_repeatLastProcessPriority ()
bool	juce_isRunningInWine ()
static void	zeroUnusedBytes (uint8 *address) noexcept
static String	removePort (const String &adr)
template<typename Member, typename Item>
static URL::InputStreamOptions	with (URL::InputStreamOptions options, Member &&member, Item &&item)
static int	calcBufferStreamBufferSize (int requestedSize, InputStream *source) noexcept
OutputStream &JUCE_CALLTYPE	operator<< (OutputStream &stream, const MemoryOutputStream &streamToRead)
template<typename IntegerType>
static void	writeIntToStream (OutputStream &stream, IntegerType number)
JUCE_API OutputStream &JUCE_CALLTYPE	operator<< (OutputStream &stream, const int number)
JUCE_API OutputStream &JUCE_CALLTYPE	operator<< (OutputStream &stream, const int64 number)
JUCE_API OutputStream &JUCE_CALLTYPE	operator<< (OutputStream &stream, const double number)
JUCE_API OutputStream &JUCE_CALLTYPE	operator<< (OutputStream &stream, const char character)
JUCE_API OutputStream &JUCE_CALLTYPE	operator<< (OutputStream &stream, const char *const text)
JUCE_API OutputStream &JUCE_CALLTYPE	operator<< (OutputStream &stream, const MemoryBlock &data)
JUCE_API OutputStream &JUCE_CALLTYPE	operator<< (OutputStream &stream, const File &fileToRead)
JUCE_API OutputStream &JUCE_CALLTYPE	operator<< (OutputStream &stream, InputStream &streamToRead)
JUCE_API OutputStream &JUCE_CALLTYPE	operator<< (OutputStream &stream, const NewLine &)
static const CPUInformation &	getCPUInformation () noexcept
static void	handleCrash (int signum)
JUCE_API String	translate (const String &text)
JUCE_API String	translate (const char *text)
JUCE_API String	translate (CharPointer_UTF8 text)
JUCE_API String	translate (const String &text, const String &resultIfNotFound)
String &	operator<< (String &string1, const NewLine &)
String &	operator+= (String &s1, const NewLine &)
String	operator+ (const NewLine &, const NewLine &)
String	operator+ (String s1, const NewLine &)
String	operator+ (const NewLine &, const char *s2)
static CharPointer_wchar_t	castToCharPointer_wchar_t (const void *t) noexcept
static size_t	findByteOffsetOfEnd (String::CharPointerType text) noexcept
JUCE_API bool JUCE_CALLTYPE	operator== (const String &s1, const String &s2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator!= (const String &s1, const String &s2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator== (const String &s1, const char *s2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator!= (const String &s1, const char *s2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator== (const String &s1, const wchar_t *s2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator!= (const String &s1, const wchar_t *s2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator== (const String &s1, StringRef s2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator!= (const String &s1, StringRef s2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator< (const String &s1, StringRef s2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator<= (const String &s1, StringRef s2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator> (const String &s1, StringRef s2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator>= (const String &s1, StringRef s2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator== (const String &s1, const CharPointer_UTF8 s2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator!= (const String &s1, const CharPointer_UTF8 s2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator== (const String &s1, const CharPointer_UTF16 s2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator!= (const String &s1, const CharPointer_UTF16 s2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator== (const String &s1, const CharPointer_UTF32 s2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator!= (const String &s1, const CharPointer_UTF32 s2) noexcept
static int	stringCompareRight (String::CharPointerType s1, String::CharPointerType s2) noexcept
static int	stringCompareLeft (String::CharPointerType s1, String::CharPointerType s2) noexcept
static int	naturalStringCompare (String::CharPointerType s1, String::CharPointerType s2, bool isCaseSensitive) noexcept
JUCE_API String JUCE_CALLTYPE	operator+ (const char *s1, const String &s2)
JUCE_API String JUCE_CALLTYPE	operator+ (const wchar_t *s1, const String &s2)
JUCE_API String JUCE_CALLTYPE	operator+ (char s1, const String &s2)
JUCE_API String JUCE_CALLTYPE	operator+ (wchar_t s1, const String &s2)
JUCE_API String JUCE_CALLTYPE	operator+ (String s1, const String &s2)
JUCE_API String JUCE_CALLTYPE	operator+ (String s1, const char *s2)
JUCE_API String JUCE_CALLTYPE	operator+ (String s1, const wchar_t *s2)
JUCE_API String JUCE_CALLTYPE	operator+ (String s1, const std::string &s2)
JUCE_API String JUCE_CALLTYPE	operator+ (String s1, char s2)
JUCE_API String JUCE_CALLTYPE	operator+ (String s1, wchar_t s2)
JUCE_API String &JUCE_CALLTYPE	operator<< (String &s1, juce_wchar s2)
JUCE_API String &JUCE_CALLTYPE	operator<< (String &s1, char s2)
JUCE_API String &JUCE_CALLTYPE	operator<< (String &s1, const char *s2)
JUCE_API String &JUCE_CALLTYPE	operator<< (String &s1, const wchar_t *s2)
JUCE_API String &JUCE_CALLTYPE	operator<< (String &s1, const String &s2)
JUCE_API String &JUCE_CALLTYPE	operator<< (String &s1, StringRef s2)
JUCE_API String &JUCE_CALLTYPE	operator<< (String &s1, const std::string &s2)
JUCE_API String &JUCE_CALLTYPE	operator<< (String &s1, uint8 number)
JUCE_API String &JUCE_CALLTYPE	operator<< (String &s1, short number)
JUCE_API String &JUCE_CALLTYPE	operator<< (String &s1, int number)
JUCE_API String &JUCE_CALLTYPE	operator<< (String &s1, long number)
JUCE_API String &JUCE_CALLTYPE	operator<< (String &s1, unsigned long number)
JUCE_API String &JUCE_CALLTYPE	operator<< (String &s1, int64 number)
JUCE_API String &JUCE_CALLTYPE	operator<< (String &s1, uint64 number)
JUCE_API String &JUCE_CALLTYPE	operator<< (String &s1, float number)
JUCE_API String &JUCE_CALLTYPE	operator<< (String &s1, double number)
JUCE_API OutputStream &JUCE_CALLTYPE	operator<< (OutputStream &stream, const String &text)
JUCE_API OutputStream &JUCE_CALLTYPE	operator<< (OutputStream &stream, StringRef text)
static bool	isQuoteCharacter (juce_wchar c) noexcept
static String::CharPointerType	findTrimmedEnd (const String::CharPointerType start, String::CharPointerType end)
template<typename Type>
static String	hexToString (Type v)
static String	getStringFromWindows1252Codepage (const char *data, size_t num)
static String	reduceLengthOfFloatString (const String &input)
static String	serialiseDouble (double input)
String &JUCE_CALLTYPE	operator<< (String &, bool)=delete
template<class traits>
std::basic_ostream< char, traits > &JUCE_CALLTYPE	operator<< (std::basic_ostream< char, traits > &stream, const String &stringToWrite)
template<class traits>
std::basic_ostream< wchar_t, traits > &JUCE_CALLTYPE	operator<< (std::basic_ostream< wchar_t, traits > &stream, const String &stringToWrite)
static int	compareStrings (const String &s1, const String &s2) noexcept
static int	compareStrings (CharPointer_UTF8 s1, const String &s2) noexcept
static int	compareStrings (const StartEndString &string1, const String &string2) noexcept
template<typename NewStringType>
static String	addPooledString (Array< String > &strings, const NewStringType &newString)
String	operator+ (String s1, StringRef s2)
String	operator+ (StringRef s1, const String &s2)
String	operator+ (const char *s1, StringRef s2)
String	operator+ (StringRef s1, const char *s2)
static SpinLock *	castToSpinLockWithoutAliasingWarning (void *s)
static CurrentThreadHolder::Ptr	getCurrentThreadHolder ()
void JUCE_API	juce_threadEntryPoint (void *userData)
static void	appendToFile (const File &f, const String &s)
static String	timeToString (double secs)
JUCE_API RelativeTime JUCE_CALLTYPE	operator+ (RelativeTime t1, RelativeTime t2) noexcept
JUCE_API RelativeTime JUCE_CALLTYPE	operator- (RelativeTime t1, RelativeTime t2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator== (RelativeTime t1, RelativeTime t2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator!= (RelativeTime t1, RelativeTime t2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator> (RelativeTime t1, RelativeTime t2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator< (RelativeTime t1, RelativeTime t2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator>= (RelativeTime t1, RelativeTime t2) noexcept
JUCE_API bool JUCE_CALLTYPE	operator<= (RelativeTime t1, RelativeTime t2) noexcept
static String	translateTimeField (int n, const char *singular, const char *plural)
static String	describeYears (int n)
static String	describeMonths (int n)
static String	describeWeeks (int n)
static String	describeDays (int n)
static String	describeHours (int n)
static String	describeMinutes (int n)
static String	describeSeconds (int n)
static int	parseFixedSizeIntAndSkip (String::CharPointerType &t, int numChars, char charToSkip) noexcept
Time	operator+ (Time time, RelativeTime delta) noexcept
Time	operator- (Time time, RelativeTime delta) noexcept
Time	operator+ (RelativeTime delta, Time time) noexcept
const RelativeTime	operator- (Time time1, Time time2) noexcept
bool	operator== (Time time1, Time time2) noexcept
bool	operator!= (Time time1, Time time2) noexcept
bool	operator< (Time time1, Time time2) noexcept
bool	operator> (Time time1, Time time2) noexcept
bool	operator<= (Time time1, Time time2) noexcept
bool	operator>= (Time time1, Time time2) noexcept
static int	getMonthNumberForCompileDate (const String &m)
std::unique_ptr< XmlElement >	parseXML (const String &textToParse)
std::unique_ptr< XmlElement >	parseXML (const File &file)
std::unique_ptr< XmlElement >	parseXMLIfTagMatches (const String &textToParse, StringRef requiredTag)
std::unique_ptr< XmlElement >	parseXMLIfTagMatches (const File &file, StringRef requiredTag)
static bool	isValidXmlNameStartCharacter (juce_wchar character) noexcept
static bool	isValidXmlNameBodyCharacter (juce_wchar character) noexcept
static const String &	getEmptyStringRef () noexcept
uint16	readUnalignedLittleEndianShort (const void *buffer)
uint32	readUnalignedLittleEndianInt (const void *buffer)
static int64	findCentralDirectoryFileHeader (InputStream &input, int &numEntries)
static bool	hasSymbolicPart (const File &root, const File &f)
OutputStream &JUCE_CALLTYPE	operator<< (OutputStream &stream, const Value &value)
static const var &	getNullVarRef () noexcept
template<typename Type>
dsp::SIMDRegister< Type > JUCE_VECTOR_CALLTYPE	jmin (dsp::SIMDRegister< Type > a, dsp::SIMDRegister< Type > b)
template<typename Type>
dsp::SIMDRegister< Type > JUCE_VECTOR_CALLTYPE	jmax (dsp::SIMDRegister< Type > a, dsp::SIMDRegister< Type > b)
static bool	isMessageType (const MemoryBlock &mb, const char *messageType) noexcept
static String	getCommandLinePrefix (const String &commandLineUniqueID)
static void	sortServiceList (std::vector< NetworkServiceDiscovery::Service > &services)
static Array< DeletedAtShutdown * > &	getDeletedAtShutdownObjects ()
JUCE_API void JUCE_CALLTYPE	initialiseJuce_GUI ()
JUCE_API void JUCE_CALLTYPE	shutdownJuce_GUI ()
uint32	maskPixelComponents (uint32 x) noexcept
uint32	clampPixelComponents (uint32 x) noexcept
static auto	operator< (const Font &a, const Font &b)
template<typename T>
static auto	operator< (const Rectangle< T > &a, const Rectangle< T > &b)
static auto	operator< (const Justification &a, const Justification &b)
static void	blurDataTriplets (uint8 *d, int num, const int delta) noexcept
static void	blurSingleChannelImage (uint8 *const data, const int width, const int height, const int lineStride, const int repetitions) noexcept
static void	blurSingleChannelImage (Image &image, int radius)
static void	drawShadowSection (Graphics &g, ColourGradient &cg, Rectangle< float > area, bool isCorner, float centreX, float centreY, float edgeX, float edgeY)
static const FontPlaceholderNames &	getFontPlaceholderNames ()
static constexpr bool	isNonBreakingSpace (const juce_wchar c)
static void	drawGlyphWithFont (Graphics &g, int glyph, const Font &font, AffineTransform t)
static bool	isBreakableGlyph (const PositionedGlyph &g) noexcept
static String	substring (const String &text, Range< int > range)
static size_t	getEdgeTableAllocationSize (int lineStride, int height) noexcept
static bool	isMarker (float value, float marker) noexcept
template<typename ValueType>
Point< ValueType >	operator* (ValueType value, Point< ValueType > p) noexcept
template<class PixelOperation>
static void	performPixelOp (const Image::BitmapData &data, const PixelOperation &pixelOp)
static std::unique_ptr< XmlElement >	findFontsConfFile ()
CGImageRef	juce_createCoreGraphicsImage (const Image &, CGColorSpaceRef)
CGContextRef	juce_getImageContext (const Image &)
static Image	getIconFromIcnsFile (const File &icnsFile, const int size)
template<typename Type>
D2D1_RECT_F	rectangleToRectF (const Rectangle< Type > &r)
static D2D1_COLOR_F	colourToD2D (Colour c)
static void	pathToGeometrySink (const Path &path, ID2D1GeometrySink *sink, const AffineTransform &transform)
static D2D1::Matrix3x2F	transformToMatrix (const AffineTransform &transform)
static D2D1_POINT_2F	pointTransformed (int x, int y, const AffineTransform &transform)
static void	rectToGeometrySink (const Rectangle< int > &rect, ID2D1GeometrySink *sink, const AffineTransform &transform)
void	notifyAccessibilityEventInternal (const AccessibilityHandler &, InternalAccessibilityEvent)
String	getAccessibleApplicationOrPluginName ()
static bool	isComponentVisibleWithinWindow (const Component &comp)
static bool	isComponentVisibleWithinParent (Component *comp)
static AccessibilityHandler *	findEnclosingHandler (Component *comp)
static AccessibilityHandler *	getUnignoredAncestor (AccessibilityHandler *handler)
static AccessibilityHandler *	findFirstUnignoredChild (const std::vector< AccessibilityHandler * > &handlers)
static AccessibilityHandler *	getFirstUnignoredDescendant (AccessibilityHandler *handler)
static std::unique_ptr< Drawable >	copyDrawableIfNotNull (const Drawable *const d)
static void	addKeyPresses (KeyPressMappingSet &set, const ApplicationCommandInfo *const ci)
static Component *	findFirstEnabledAncestor (Component *in)
template<typename FocusContainerFn>
static Component *	findContainer (const Component *child, FocusContainerFn isFocusContainer)
bool	operator== (const Displays::Display &d1, const Displays::Display &d2) noexcept
bool	operator!= (const Displays::Display &d1, const Displays::Display &d2) noexcept
static void	processDisplay (DisplayNode *currentNode, Array< DisplayNode > &allNodes)
static bool	replaceColourInFill (FillType &fill, Colour original, Colour replacement)
Image	juce_createIconForFile (const File &file)
bool	juce_areThereAnyAlwaysOnTopWindows ()
bool	isEmbeddedInForegroundProcess (Component *c)
static bool	isForegroundOrEmbeddedProcess (Component *viewComponent)
bool	isWindowOnCurrentVirtualDesktop (void *)
template<typename Item>
static Array< Item >	operator+ (const Array< Item > &a, const Array< Item > &b)
constexpr Grid::Px	operator""_px (long double px)
constexpr Grid::Px	operator""_px (unsigned long long px)
constexpr Grid::Fr	operator""_fr (unsigned long long fr)
static bool	viewportWouldScrollOnEvent (const Viewport *vp, const MouseInputSource &src) noexcept
static int	rescaleMouseWheelDistance (float distance, int singleStepSize) noexcept
static bool	isUpDownKeyPress (const KeyPress &key)
static bool	isLeftRightKeyPress (const KeyPress &key)
static Typeface::Ptr	getTypefaceForFontFromLookAndFeel (const Font &font)
static void	drawTriangle (Graphics &g, float x1, float y1, float x2, float y2, float x3, float y3, Colour fill, Colour outline)
static std::unique_ptr< Drawable >	createDrawableFromSVG (const char *data)
static Path	createPathFromData (float height, const unsigned char *data, size_t size)
static void	drawButtonShape (Graphics &g, const Path &outline, Colour baseColour, float height)
static std::unique_ptr< Drawable >	createDrawableFromImage (const Image &im)
template<typename Member, typename Item>
static PopupMenu::Options	with (PopupMenu::Options options, Member &&member, Item &&item)
static Rectangle< float >	getLogoArea (Rectangle< float > parentRect)
bool	juce_performDragDropFiles (const StringArray &, const bool copyFiles, bool &shouldStop)
bool	juce_performDragDropText (const String &, bool &shouldStop)
auto	makeMouseEvent (MouseInputSource source, const PointerState &ps, ModifierKeys modifiers, Component *eventComponent, Component *originator, Time eventTime, Point< float > mouseDownPos, Time mouseDownTime, int numberOfClicks, bool mouseWasDragged)
static void	loadSDKDependentMethods ()
static constexpr auto	getClassName (AccessibilityRole role)
static jobject	getSourceView (const AccessibilityHandler &handler)
static bool	isStartingUpOrShuttingDown ()
static bool	isHandlerValid (const AccessibilityHandler &handler)
static bool	areAnyAccessibilityClientsActive ()
template<typename Callback>
void	getProviderWithCheckedWrapper (const AccessibilityHandler &handler, Callback &&callback)
void	sendAccessibilityAutomationEvent (const AccessibilityHandler &handler, EVENTID event)
void	sendAccessibilityPropertyChangedEvent (const AccessibilityHandler &handler, PROPERTYID property, VARIANT newValue)
static String	getAutomationId (const AccessibilityHandler &handler)
static auto	roleToControlTypeId (AccessibilityRole roleType)
JUCE_COMRESULT	addHandlersToArray (const std::vector< const AccessibilityHandler * > &handlers, SAFEARRAY **pRetVal)
template<typename Value, typename Object, typename Callback>
JUCE_COMRESULT	withCheckedComArgs (Value *pRetVal, Object &handle, Callback &&callback)
static LinuxComponentPeer *	getPeerForDragEvent (Component *sourceComp)
static int	showDialog (const MessageBoxOptions &options, ModalComponentManager::Callback *callback, Async async)
void	juce_LinuxAddRepaintListener (ComponentPeer *peer, Component *dummy)
void	juce_LinuxRemoveRepaintListener (ComponentPeer *peer, Component *dummy)
static bool	canUseMultiTouch ()
static void	checkForPointerAPI ()
static void	loadDPIAwarenessFunctions ()
static void	setDPIAwareness ()
static bool	isPerMonitorDPIAwareProcess ()
static bool	isPerMonitorDPIAwareWindow (HWND nativeWindow)
static bool	isPerMonitorDPIAwareThread (GetThreadDPIAwarenessContextFunc getThreadDPIAwarenessContextIn=getThreadDPIAwarenessContext, GetAwarenessFromDpiAwarenessContextFunc getAwarenessFromDPIAwarenessContextIn=getAwarenessFromDPIAwarenessContext)
static double	getGlobalDPI ()
static Rectangle< int >	rectangleFromRECT (RECT r) noexcept
static RECT	RECTFromRectangle (Rectangle< int > r) noexcept
static Point< int >	pointFromPOINT (POINT p) noexcept
static POINT	POINTFromPoint (Point< int > p) noexcept
static const Displays::Display *	getCurrentDisplayFromScaleFactor (HWND hwnd)
template<typename ValueType>
static Rectangle< ValueType >	convertPhysicalScreenRectangleToLogical (Rectangle< ValueType > r, HWND h) noexcept
template<typename ValueType>
static Rectangle< ValueType >	convertLogicalScreenRectangleToPhysical (Rectangle< ValueType > r, HWND h) noexcept
static Point< int >	convertPhysicalScreenPointToLogical (Point< int > p, HWND h) noexcept
static Point< int >	convertLogicalScreenPointToPhysical (Point< int > p, HWND h) noexcept
JUCE_API double	getScaleFactorForWindow (HWND h)
static void	setWindowPos (HWND hwnd, Rectangle< int > bounds, UINT flags, bool adjustTopLeft=false)
static RECT	getWindowScreenRect (HWND hwnd)
static RECT	getWindowClientRect (HWND hwnd)
static void	setWindowZOrder (HWND hwnd, HWND insertAfter)
int64	getMouseEventTime ()
Image	createSnapshotOfNativeWindow (void *nativeWindowHandle)
	JUCE_IUNKNOWNCLASS (ITipInvocation, "37c994e7-432b-4834-a2f7-dce1f13b834b")
JUCE_API ComponentPeer *	createNonRepaintingEmbeddedWindowsPeer (Component &component, void *parentHWND)
bool	offerKeyMessageToJUCEWindow (MSG &m)
static DWORD	getProcess (HWND hwnd)
static BOOL CALLBACK	enumAlwaysOnTopWindows (HWND hwnd, LPARAM lParam)
static std::unique_ptr< WindowsMessageBoxBase >	createMessageBox (const MessageBoxOptions &options, std::unique_ptr< ModalComponentManager::Callback > callback)
static int	showDialog (const MessageBoxOptions &options, ModalComponentManager::Callback *callbackIn, AlertWindowMappings::MapFn mapFn)
static BOOL CALLBACK	enumMonitorsProc (HMONITOR hm, HDC, LPRECT, LPARAM userInfo)
static HICON	extractFileHICON (const File &file)
static Cursor	createDraggingHandCursor ()
ComponentPeer *	getPeerFor (::Window)
static void	updateKeyStates (int keycode, bool press) noexcept
static void	updateKeyModifiers (int status) noexcept
static bool	updateKeyModifiersFromSym (KeySym sym, bool press) noexcept
static int	getAllEventsMask (bool ignoresMouseClicks)
static Cursor	createDraggingHandCursor ()
static bool	hasWorkAreaData (const XWindowSystemUtilities::GetXProperty &prop)
static Rectangle< int >	getWorkArea (const XWindowSystemUtilities::GetXProperty &prop)
static void	addAtomIfExists (bool condition, const char *key, ::Display *display, std::vector< Atom > &atoms)
::Window	juce_createKeyProxyWindow (ComponentPeer *peer)
void	juce_deleteKeyProxyWindow (::Window keyProxy)
template<typename EventType>
static Point< float >	getLogicalMousePos (const EventType &e, double scaleFactor) noexcept
static int64	getEventTime (::Time t)
template<typename EventType>
static int64	getEventTime (const EventType &t)
static void	updateButtonTickColour (ToggleButton *button, bool usingDefault)
static void	comboBoxPopupMenuFinishedCallback (int result, ComboBox *combo)
static void	copyColourIfSpecified (Label &l, TextEditor &ed, int colourID, int targetColourID)
template<typename RowComponentType>
static AccessibilityActions	getListRowAccessibilityActions (RowComponentType &rowComponent)
static double	getStepSize (const Slider &slider)
static void	tableHeaderMenuCallback (int result, TableHeaderComponent *tableHeader, int columnIdClicked)
static int	getItemDepth (const TreeViewItem *item)
static void	addAllSelectedItemIds (TreeViewItem *item, XmlElement &parent)
static String	escapeSlashesInTreeViewItemName (const String &s)
static juce_wchar	getDefaultPasswordChar () noexcept
static int	showMaybeAsync (const MessageBoxOptions &options, ModalComponentManager::Callback *callbackIn, AlertWindowMappings::MapFn mapFn)
void	juce_checkCurrentlyFocusedTopLevelWindow ()
static int	getCharacterType (juce_wchar character) noexcept
static void	codeEditorMenuCallback (int menuResult, CodeEditorComponent *editor)
template<typename Iterator>
static void	skipToEndOfXmlDTD (Iterator &source) noexcept
template<typename Iterator>
static void	skipToEndOfXmlComment (Iterator &source) noexcept
bool	juce_handleXEmbedEvent (ComponentPeer *, void *)
unsigned long	juce_getCurrentFocusWindow (ComponentPeer *)
static void	resetKeyMappingsToDefaultsCallback (int result, KeyMappingEditorComponent *owner)
int	juce_gtkWebkitMain (int argc, const char *argv[])
NSMenu *	createNSMenu (const PopupMenu &, const String &name, int topLevelMenuId, int topLevelIndex, bool addDelegate)
LRESULT	juce_offerEventToActiveXControl (::MSG &msg)

Variables
static ADSRTests	adsrTests
static void *	juce_libjackHandle = nullptr
	jack_client_close
jack_client_t *	client
jack_client_t client	jack_deactivate
jack_client_t client jack_client_t client	jack_get_sample_rate
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback	function
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void *	arg
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg	jack_port_get_total_latency
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t *	port
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void(*	func )(const char *))
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func	jack_get_ports
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char *	port_name_pattern
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char *	type_name_pattern
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long	flags
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags	jack_port_name
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port	jack_port_by_id
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port jack_client_t jack_port_id_t	port_id
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port jack_client_t jack_port_id_t port_id	jack_port_connected_to
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port jack_client_t jack_port_id_t port_id const jack_port_t const char *	port_name
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port jack_client_t jack_port_id_t port_id const jack_port_t const char port_name	jack_port_flags
jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port jack_client_t jack_port_id_t port_id const jack_port_t const char port_name const jack_port_t port void *	ptr
constexpr auto	juceAudioObjectPropertyElementMain
JUCE_END_IGNORE_WARNINGS_GCC_LIKE constexpr auto	juceAudioHardwareServiceDeviceProperty_VirtualMainVolume
constexpr int	maxNumASIODevices = 16
static ASIOAudioIODevice *	currentASIODev [maxNumASIODevices] = {}
HWND	juce_messageWindowHandle = nullptr
static const char *const	aiffFormatName = "AIFF file"
static const char *const	wavFormatName = "WAV file"
static int	memoryReadDummyVariable
static LV2PluginFormatTests	lv2PluginFormatTests
static VST3PluginFormatTests	vst3PluginFormatTests
static ThreadLocalValue< AudioProcessor::WrapperType >	wrapperTypeBeingCreated
const uint32	magicXmlNumber = 0x21324356
createUnityPeerFunctionType	juce_createUnityPeerFn = nullptr
static HashMapTest	hashMapTest
constexpr Nullopt	nullopt { 0 }
static OptionalUnitTest	optionalUnitTest
static LockedRandom	lockedRandom
static this_will_fail_to_link_if_some_of_your_compile_units_are_built_in_release_mode	compileUnitMismatchSentinel
const constexpr double	double_Pi = MathConstants<double>::pi
const constexpr float	float_Pi = MathConstants<float>::pi
static const char	base64EncodingTable [] = ".ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+"
static const char	base64DecodingTable []
const char *const *	juce_argv = nullptr
int	juce_argc = 0
template<typename Class>
ObjCLifetimeManagedClass< Class >	ObjCLifetimeManagedClass< Class >::objCLifetimeManagedClass
static HiResCounterHandler	hiResCounterHandler
static SleepEvent	sleepEvent
static int	lastProcessPriority = -1
static void *	currentModuleHandle = nullptr
static const SocketHandle	invalidSocket = -1
static SystemStats::CrashHandlerFunction	globalCrashHandler = nullptr
NewLine	newLine
constexpr StringHolder	emptyString
static const char	hexDigits [] = "0123456789abcdef"
static const juce_wchar	emptyChar = 0
static const int	minNumberOfStringsForGarbageCollection = 300
static const uint32	garbageCollectionInterval = 30000
static char	currentThreadHolderLock [sizeof(SpinLock)]
static const char *const	shortMonthNames [] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }
static const char *const	longMonthNames [] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" }
static const String	juce_xmltextContentAttributeName ("text")
static ValueTreePropertyWithDefaultTests	valueTreePropertyWithDefaultTests
static const char *	startMessage = "__ipc_st"
static const char *	killMessage = "__ipc_k_"
static const char *	pingMessage = "__ipc_p_"
static SpinLock	deletedAtShutdownLock
static int	numScopedInitInstances = 0
CheckEventBlockedByModalComps	isEventBlockedByModalComps = nullptr
SettingChangeCallbackFunc	settingChangeCallback = nullptr
class JUCE_API juce::PixelARGB	JUCE_PACKED
GetTypefaceForFont	juce_getTypefaceForFont = nullptr
void(*	clearOpenGLGlyphCache )() = nullptr
static RectangleUnitTest	rectangleUnitTest
static const char	colourPropertyPrefix [] = "jcclr_"
static const Identifier	juce_explicitFocusOrderId ("_jexfo")
static constexpr int	millisecondsToDisplaySplash = 2000
static constexpr int	splashScreenFadeOutTime = 2000
static constexpr int	splashScreenLogoWidth = 123
static constexpr int	splashScreenLogoHeight = 63
static uint32	splashDisplayTime = 0
static bool	splashHasStartedFading = false
static int	doubleClickTimeOutMs = 400
static jmethodID	nodeInfoSetEditable = nullptr
static jmethodID	nodeInfoSetTextSelection = nullptr
static jmethodID	nodeInfoSetLiveRegion = nullptr
static jmethodID	accessibilityEventSetContentChangeTypes = nullptr
static int	numAlwaysOnTopPeers = 0
static bool	screenSaverAllowed = true
static bool	shouldDeactivateTitleBar = true
static RegisterTouchWindowFunc	registerTouchWindow = nullptr
static GetTouchInputInfoFunc	getTouchInputInfo = nullptr
static CloseTouchInputHandleFunc	closeTouchInputHandle = nullptr
static GetGestureInfoFunc	getGestureInfo = nullptr
static bool	hasCheckedForMultiTouch = false
static GetPointerTypeFunc	getPointerTypeFunction = nullptr
static GetPointerTouchInfoFunc	getPointerTouchInfo = nullptr
static GetPointerPenInfoFunc	getPointerPenInfo = nullptr
static bool	canUsePointerAPI = false
static SetProcessDPIAwareFunc	setProcessDPIAware = nullptr
static SetProcessDPIAwarenessContextFunc	setProcessDPIAwarenessContext = nullptr
static SetProcessDPIAwarenessFunc	setProcessDPIAwareness = nullptr
static SetThreadDPIAwarenessContextFunc	setThreadDPIAwarenessContext = nullptr
static GetDPIForMonitorFunc	getDPIForMonitor = nullptr
static GetDPIForWindowFunc	getDPIForWindow = nullptr
static GetProcessDPIAwarenessFunc	getProcessDPIAwareness = nullptr
static GetWindowDPIAwarenessContextFunc	getWindowDPIAwarenessContext = nullptr
static GetThreadDPIAwarenessContextFunc	getThreadDPIAwarenessContext = nullptr
static GetAwarenessFromDpiAwarenessContextFunc	getAwarenessFromDPIAwarenessContext = nullptr
static EnableNonClientDPIScalingFunc	enableNonClientDPIScaling = nullptr
static bool	hasCheckedForDPIAwareness = false
const int	extendedKeyModifier = 0x10000
static TaskDialogIndirectFunc	taskDialogIndirect = nullptr
static std::unique_ptr< ScreenSaverDefeater >	screenSaverDefeater
XContext	windowHandleXContext
static std::unordered_map< LinuxComponentPeer *, X11DragState >	dragAndDropStateMap
constexpr int	rightEdgeSpace = 2
static constexpr int	callOutBoxDismissCommandId = 0x4f83a04b
static uint32	lastUniquePeerID = 1
const float	bubblePaddingX = 20.0f
const float	bubblePaddingY = 14.0f

Typedef Documentation

AudioSampleBuffer

using juce::AudioSampleBuffer = AudioBuffer<float>

A multi-channel buffer of 32-bit floating point audio samples.

This type is here for backwards compatibility with the older AudioSampleBuffer class, which was fixed for 32-bit data, but is otherwise the same as the new templated AudioBuffer class.

See also

AudioBuffer

CatmullRomInterpolator

using juce::CatmullRomInterpolator = Interpolators::CatmullRom

An interpolator for resampling a stream of floats using Catmull-Rom interpolation.

Note that the resampler is stateful, so when there's a break in the continuity of the input stream you're feeding it, you should call reset() before feeding it any new data. And like with any other stateful filter, if you're resampling multiple channels, make sure each one uses its own CatmullRomInterpolator object.

See also

GenericInterpolator

LagrangeInterpolator, WindowedSincInterpolator, LinearInterpolator, ZeroOrderHoldInterpolator

@tags{Audio}

CFUniquePtr

template<typename CFType>

using juce::CFUniquePtr = std::unique_ptr<typename std::remove_pointer<CFType>::type, CFObjectDeleter<CFType>>

CharPointer_wchar_t

using juce::CharPointer_wchar_t = CharPointer_UTF32

CheckEventBlockedByModalComps

typedef bool(* juce::CheckEventBlockedByModalComps)(const MSG &) = bool (*)(const MSG&)

CloseTouchInputHandleFunc

using juce::CloseTouchInputHandleFunc = BOOL (WINAPI*) (HTOUCHINPUT)

CommandID

using juce::CommandID = int

A type used to hold the unique ID for an application command.

This is a numeric type, so it can be stored as an integer.

See also

ApplicationCommandInfo, ApplicationCommandManager, ApplicationCommandTarget, KeyPressMappingSet

createUnityPeerFunctionType

typedef ComponentPeer *(* juce::createUnityPeerFunctionType) (Component &)

DisableIfSameOrDerived

template<typename A, typename B>

using juce::DisableIfSameOrDerived = typename std::enable_if_t<! std::is_base_of<A, std::remove_reference_t<B>>::value>

Can be used to disable template constructors that would otherwise cause ambiguity with compiler-generated copy and move constructors.

Adapted from https://ericniebler.com/2013/08/07/universal-references-and-the-copy-constructo/

DPI_AWARENESS_CONTEXT

typedef HANDLE juce::DPI_AWARENESS_CONTEXT

EnableNonClientDPIScalingFunc

using juce::EnableNonClientDPIScalingFunc = BOOL (WINAPI*) (HWND)

GetAwarenessFromDpiAwarenessContextFunc

using juce::GetAwarenessFromDpiAwarenessContextFunc = DPI_Awareness (WINAPI*) (DPI_AWARENESS_CONTEXT)

GetDPIForMonitorFunc

using juce::GetDPIForMonitorFunc = HRESULT (WINAPI*) (HMONITOR, Monitor_DPI_Type, UINT*, UINT*)

GetDPIForWindowFunc

using juce::GetDPIForWindowFunc = UINT (WINAPI*) (HWND)

GetGestureInfoFunc

using juce::GetGestureInfoFunc = BOOL (WINAPI*) (HGESTUREINFO, GESTUREINFO*)

GetPointerPenInfoFunc

using juce::GetPointerPenInfoFunc = BOOL (WINAPI*) (UINT32, POINTER_PEN_INFO*)

GetPointerTouchInfoFunc

using juce::GetPointerTouchInfoFunc = BOOL (WINAPI*) (UINT32, POINTER_TOUCH_INFO*)

GetPointerTypeFunc

using juce::GetPointerTypeFunc = BOOL (WINAPI*) (UINT32, POINTER_INPUT_TYPE*)

GetProcessDPIAwarenessFunc

using juce::GetProcessDPIAwarenessFunc = HRESULT (WINAPI*) (HANDLE, DPI_Awareness*)

GetSystemMetricsForDpiFunc

using juce::GetSystemMetricsForDpiFunc = int (WINAPI*) (int, UINT)

GetThreadDPIAwarenessContextFunc

using juce::GetThreadDPIAwarenessContextFunc = DPI_AWARENESS_CONTEXT (WINAPI*) ()

GetTouchInputInfoFunc

using juce::GetTouchInputInfoFunc = BOOL (WINAPI*) (HTOUCHINPUT, UINT, TOUCHINPUT*, int)

GetTypefaceForFont

typedef Typeface::Ptr(* juce::GetTypefaceForFont)(const Font &) = Typeface::Ptr (*)(const Font&)

GetWindowDPIAwarenessContextFunc

using juce::GetWindowDPIAwarenessContextFunc = DPI_AWARENESS_CONTEXT (WINAPI*) (HWND)

HGESTUREINFO

typedef HANDLE juce::HGESTUREINFO

HSTRING

typedef HSTRING_PRIVATE* juce::HSTRING

HTOUCHINPUT

typedef HANDLE juce::HTOUCHINPUT

HWND

typedef HWND__* juce::HWND

int16

using juce::int16 = signed short

A platform-independent 16-bit signed integer type.

int32

using juce::int32 = signed int

A platform-independent 32-bit signed integer type.

int64

using juce::int64 = long long

A platform-independent 64-bit integer type.

int8

using juce::int8 = signed char

A platform-independent 8-bit signed integer type.

juce_recvsend_size_t

using juce::juce_recvsend_size_t = socklen_t

juce_socklen_t

using juce::juce_socklen_t = socklen_t

juce_wchar

using juce::juce_wchar = wchar_t

A platform-independent 32-bit unicode character type.

LagrangeInterpolator

using juce::LagrangeInterpolator = Interpolators::Lagrange

An interpolator for resampling a stream of floats using 4-point lagrange interpolation.

Note that the resampler is stateful, so when there's a break in the continuity of the input stream you're feeding it, you should call reset() before feeding it any new data. And like with any other stateful filter, if you're resampling multiple channels, make sure each one uses its own LagrangeInterpolator object.

See also

GenericInterpolator

CatmullRomInterpolator, WindowedSincInterpolator, LinearInterpolator, ZeroOrderHoldInterpolator

@tags{Audio}

LinearInterpolator

using juce::LinearInterpolator = Interpolators::Linear

An interpolator for resampling a stream of floats using linear interpolation.

Note that the resampler is stateful, so when there's a break in the continuity of the input stream you're feeding it, you should call reset() before feeding it any new data. And like with any other stateful filter, if you're resampling multiple channels, make sure each one uses its own LinearInterpolator object.

See also

GenericInterpolator

LagrangeInterpolator, CatmullRomInterpolator, WindowedSincInterpolator, ZeroOrderHoldInterpolator

@tags{Audio}

LinearSmoothedValue

template<typename FloatType>

using juce::LinearSmoothedValue = SmoothedValue <FloatType, ValueSmoothingTypes::Linear>

MessageCallbackFunction

using juce::MessageCallbackFunction = void* (void* userData)

See MessageManager::callFunctionOnMessageThread() for use of this function type.

MidiKeyboardStateListener

using juce::MidiKeyboardStateListener = MidiKeyboardState::Listener

NSUniquePtr

template<typename NSType>

using juce::NSUniquePtr = std::unique_ptr<NSType, NSObjectDeleter>

PEN_FLAGS

typedef UINT32 juce::PEN_FLAGS

PEN_MASK

typedef UINT32 juce::PEN_MASK

POINTER_FLAGS

typedef UINT32 juce::POINTER_FLAGS

POINTER_INPUT_TYPE

typedef DWORD juce::POINTER_INPUT_TYPE

pointer_sized_int

using juce::pointer_sized_int = int

A signed integer type that's guaranteed to be large enough to hold a pointer without truncating it.

pointer_sized_uint

using juce::pointer_sized_uint = unsigned int

An unsigned integer type that's guaranteed to be large enough to hold a pointer without truncating it.

REFERENCE_TIME

using juce::REFERENCE_TIME = LONGLONG

RegisterTouchWindowFunc

using juce::RegisterTouchWindowFunc = BOOL (WINAPI*) (HWND, ULONG)

ScopedLock

using juce::ScopedLock = CriticalSection::ScopedLockType

Automatically locks and unlocks a CriticalSection object.

You can use a ScopedLock as a local variable to provide RAII-based locking of a CriticalSection.

e.g.

struct MyObject
{
    CriticalSection objectLock;
 
    // assuming that this example function will be called by multiple threads
    void foo()
    {
        const ScopedLock myScopedLock (objectLock);
 
        // objectLock is now locked..
 
        ...do some thread-safe work here...
 
        // ..and objectLock gets unlocked here, as myScopedLock goes out of
        // scope at the end of the block
    }
};

See also

CriticalSection, ScopedUnlock

ScopedTryLock

using juce::ScopedTryLock = CriticalSection::ScopedTryLockType

Automatically tries to lock and unlock a CriticalSection object.

Use one of these as a local variable to control access to a CriticalSection.

e.g.

struct MyObject
{
    CriticalSection objectLock;
 
    void foo()
    {
        const ScopedTryLock myScopedTryLock (objectLock);
 
        // Unlike using a ScopedLock, this may fail to actually get the lock, so you
        // must call the isLocked() method before making any assumptions..
        if (myScopedTryLock.isLocked())
        {
           ...safely do some work...
        }
        else
        {
            // If we get here, then our attempt at locking failed because another thread had already locked it..
        }
    }
};

See also

CriticalSection::tryEnter, ScopedLock, ScopedUnlock, ScopedReadLock

ScopedUnlock

using juce::ScopedUnlock = CriticalSection::ScopedUnlockType

Automatically unlocks and re-locks a CriticalSection object.

This is the reverse of a ScopedLock object - instead of locking the critical section for the lifetime of this object, it unlocks it.

Make sure you don't try to unlock critical sections that aren't actually locked!

e.g.

struct MyObject
{
    CriticalSection objectLock;
 
    void foo()
    {
        {
            const ScopedLock myScopedLock (objectLock);
 
            // objectLock is now locked..
 
            {
                ScopedUnlock myUnlocker (objectLock);
 
                // ..and now unlocked..
            }
 
            // ..and now locked again..
        }
 
        // ..and finally unlocked.
    }
};

See also

CriticalSection, ScopedLock

SetProcessDPIAwareFunc

using juce::SetProcessDPIAwareFunc = BOOL (WINAPI*) ()

SetProcessDPIAwarenessContextFunc

using juce::SetProcessDPIAwarenessContextFunc = BOOL (WINAPI*) (DPI_AWARENESS_CONTEXT)

SetProcessDPIAwarenessFunc

using juce::SetProcessDPIAwarenessFunc = HRESULT (WINAPI*) (DPI_Awareness)

SetThreadDPIAwarenessContextFunc

using juce::SetThreadDPIAwarenessContextFunc = DPI_AWARENESS_CONTEXT (WINAPI*) (DPI_AWARENESS_CONTEXT)

SettingChangeCallbackFunc

typedef void(* juce::SettingChangeCallbackFunc)(void) = void (*)(void)

SocketHandle

using juce::SocketHandle = int

StringMap

using juce::StringMap = std::unordered_map<String, String>

TaskDialogIndirectFunc

using juce::TaskDialogIndirectFunc = HRESULT (WINAPI*) (const TASKDIALOGCONFIG*, INT*, INT*, BOOL*)

TOUCH_FLAGS

typedef UINT32 juce::TOUCH_FLAGS

TOUCH_MASK

typedef UINT32 juce::TOUCH_MASK

uint16

using juce::uint16 = unsigned short

A platform-independent 16-bit unsigned integer type.

uint32

using juce::uint32 = unsigned int

A platform-independent 32-bit unsigned integer type.

uint64

using juce::uint64 = unsigned long long

A platform-independent 64-bit unsigned integer type.

uint8

using juce::uint8 = unsigned char

A platform-independent 8-bit unsigned integer type.

ViewportDragPosition

using juce::ViewportDragPosition = AnimatedPosition<AnimatedPositionBehaviours::ContinuousWithMomentum>

WindowedSincInterpolator

using juce::WindowedSincInterpolator = Interpolators::WindowedSinc

An interpolator for resampling a stream of floats using high order windowed (hann) sinc interpolation, recommended for high quality resampling.

Note that the resampler is stateful, so when there's a break in the continuity of the input stream you're feeding it, you should call reset() before feeding it any new data. And like with any other stateful filter, if you're resampling multiple channels, make sure each one uses its own LinearInterpolator object.

See also

GenericInterpolator

LagrangeInterpolator, CatmullRomInterpolator, LinearInterpolator, ZeroOrderHoldInterpolator

@tags{Audio}

ZeroOrderHoldInterpolator

using juce::ZeroOrderHoldInterpolator = Interpolators::ZeroOrderHold

An interpolator for resampling a stream of floats using zero order hold interpolation.

Note that the resampler is stateful, so when there's a break in the continuity of the input stream you're feeding it, you should call reset() before feeding it any new data. And like with any other stateful filter, if you're resampling multiple channels, make sure each one uses its own ZeroOrderHoldInterpolator object.

See also

GenericInterpolator

LagrangeInterpolator, CatmullRomInterpolator, WindowedSincInterpolator, LinearInterpolator

@tags{Audio}

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
KeyPressEventType

anonymous enum

anonymous enum

Enumerator
DEVICE_STATE_ACTIVE

anonymous enum

anonymous enum

Enumerator
PT_TOUCH
PT_PEN

anonymous enum

anonymous enum

Enumerator
XEMBED_FOCUS_CURRENT
XEMBED_FOCUS_FIRST
XEMBED_FOCUS_LAST

anonymous enum

anonymous enum

Enumerator
kAudioUnitProperty_SupportsMPE	Custom AudioUnit property used to indicate MPE support

anonymous enum

anonymous enum

Enumerator
POINTER_FLAG_NONE
POINTER_FLAG_NEW
POINTER_FLAG_INRANGE
POINTER_FLAG_INCONTACT
POINTER_FLAG_FIRSTBUTTON
POINTER_FLAG_SECONDBUTTON
POINTER_FLAG_THIRDBUTTON
POINTER_FLAG_FOURTHBUTTON
POINTER_FLAG_FIFTHBUTTON
POINTER_FLAG_PRIMARY
POINTER_FLAG_CONFIDENCE
POINTER_FLAG_CANCELED
POINTER_FLAG_DOWN
POINTER_FLAG_UPDATE
POINTER_FLAG_UP
POINTER_FLAG_WHEEL
POINTER_FLAG_HWHEEL
POINTER_FLAG_CAPTURECHANGED
POINTER_FLAG_HASTRANSFORM

anonymous enum

anonymous enum

Enumerator
XEMBED_MAPPED

anonymous enum

anonymous enum

Enumerator
maxXEmbedVersionToSupport

anonymous enum

anonymous enum

Enumerator
PEN_MASK_NONE
PEN_MASK_PRESSURE
PEN_MASK_ROTATION
PEN_MASK_TILT_X
PEN_MASK_TILT_Y

anonymous enum

anonymous enum

Enumerator
WM_NCPOINTERUPDATE
WM_NCPOINTERDOWN
WM_NCPOINTERUP
WM_POINTERUPDATE
WM_POINTERDOWN
WM_POINTERUP
WM_POINTERENTER
WM_POINTERLEAVE
WM_POINTERACTIVATE
WM_POINTERCAPTURECHANGED
WM_TOUCHHITTESTING
WM_POINTERWHEEL
WM_POINTERHWHEEL
WM_POINTERHITTEST

anonymous enum

anonymous enum

Enumerator
U_ISOFS_SUPER_MAGIC
U_MSDOS_SUPER_MAGIC
U_NFS_SUPER_MAGIC
U_SMB_SUPER_MAGIC

anonymous enum

anonymous enum

Enumerator
WM_TOUCH
TOUCHEVENTF_MOVE
TOUCHEVENTF_DOWN
TOUCHEVENTF_UP

anonymous enum

anonymous enum

Enumerator
TOUCH_MASK_NONE
TOUCH_MASK_CONTACTAREA
TOUCH_MASK_ORIENTATION
TOUCH_MASK_PRESSURE

anonymous enum

anonymous enum

Enumerator
XEMBED_EMBEDDED_NOTIFY
XEMBED_WINDOW_ACTIVATE
XEMBED_WINDOW_DEACTIVATE
XEMBED_REQUEST_FOCUS
XEMBED_FOCUS_IN
XEMBED_FOCUS_OUT
XEMBED_FOCUS_NEXT
XEMBED_FOCUS_PREV
XEMBED_MODALITY_ON
XEMBED_MODALITY_OFF
XEMBED_REGISTER_ACCELERATOR
XEMBED_UNREGISTER_ACCELERATOR
XEMBED_ACTIVATE_ACCELERATOR

anonymous enum

anonymous enum

Enumerator
AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY
AUDCLNT_BUFFERFLAGS_SILENT

anonymous enum

anonymous enum

Enumerator
clickMessageId

anonymous enum

anonymous enum

Enumerator
magicCoordWorkerConnectionHeader

anonymous enum

anonymous enum

Enumerator
specialMessageSize
defaultTimeoutMs

AccessibilityActionType

enum class juce::AccessibilityActionType

strong

An action that can be performed by an accessible UI element.

@tags{Accessibility}

Enumerator
press	Represents a "press" action. This will be called when the user "clicks" the UI element using an accessibility client.
toggle	Represents a "toggle" action. This will be called when the user toggles the state of a UI element, for example a toggle button or the selection of a list item.
focus	Indicates that the UI element has received focus. This will be called when a UI element receives focus from an accessibility client, or keyboard focus from the application.
showMenu	Represents the user showing a contextual menu for a UI element. This will be called for UI elements which expand and collapse to show contextual information or menus, or show a popup.

AccessibilityEvent

enum class juce::AccessibilityEvent

strong

A list of events that can be notified to any subscribed accessibility clients.

To post a notification, call AccessibilityHandler::notifyAccessibilityEvent on the associated handler with the appropriate AccessibilityEvent type and listening clients will be notified.

@tags{Accessibility}

Enumerator
valueChanged	Indicates that the UI element's value has changed. This should be called on the handler that implements AccessibilityValueInterface for the UI element that has changed.
titleChanged	Indicates that the title of the UI element has changed. This should be called on the handler whose title has changed.
structureChanged	Indicates that the structure of the UI elements has changed in a significant way. This should be called on the top-level handler whose structure has changed.
textSelectionChanged	Indicates that the selection of a text element has changed. This should be called on the handler that implements AccessibilityTextInterface for the text element that has changed.
textChanged	Indicates that the visible text of a text element has changed. This should be called on the handler that implements AccessibilityTextInterface for the text element that has changed.
rowSelectionChanged	Indicates that the selection of rows in a list or table has changed. This should be called on the handler that implements AccessibilityTableInterface for the UI element that has changed.

AccessibilityRole

enum class juce::AccessibilityRole

strong

The list of available roles for an AccessibilityHandler object.

When creating a custom AccessibilityHandler you should select the role that best describes the UI element being represented.

@tags{Accessibility}

Enumerator
button
toggleButton
radioButton
comboBox
image
slider
label
staticText
editableText
menuItem
menuBar
popupMenu
table
tableHeader
column
row
cell
hyperlink
list
listItem
tree
treeItem
progressBar
group
dialogWindow
window
scrollBar
tooltip
splashScreen
ignored
unspecified

Async

enum class juce::Async

strong

Enumerator
no
yes

AUDCLNT_SHAREMODE

enum juce::AUDCLNT_SHAREMODE

Enumerator
AUDCLNT_SHAREMODE_SHARED
AUDCLNT_SHAREMODE_EXCLUSIVE

AUDIO_STREAM_CATEGORY

enum juce::AUDIO_STREAM_CATEGORY

Enumerator
AudioCategory_Other
AudioCategory_ForegroundOnlyMedia
AudioCategory_BackgroundCapableMedia
AudioCategory_Communications
AudioCategory_Alerts
AudioCategory_SoundEffects
AudioCategory_GameEffects
AudioCategory_GameMedia
AudioCategory_GameChat
AudioCategory_Speech
AudioCategory_Movie
AudioCategory_Media

AudioSessionDisconnectReason

enum juce::AudioSessionDisconnectReason

Enumerator
DisconnectReasonDeviceRemoval
DisconnectReasonServerShutdown
DisconnectReasonFormatChanged
DisconnectReasonSessionLogoff
DisconnectReasonSessionDisconnected
DisconnectReasonExclusiveModeOverride

AudioSessionState

enum juce::AudioSessionState

Enumerator
AudioSessionStateInactive
AudioSessionStateActive
AudioSessionStateExpired

AVRT_PRIORITY

enum juce::AVRT_PRIORITY

Enumerator
AVRT_PRIORITY_LOW
AVRT_PRIORITY_NORMAL
AVRT_PRIORITY_HIGH
AVRT_PRIORITY_CRITICAL

DPI_Awareness

enum juce::DPI_Awareness

Enumerator
DPI_Awareness_Invalid
DPI_Awareness_Unaware
DPI_Awareness_System_Aware
DPI_Awareness_Per_Monitor_Aware

EDataFlow

enum juce::EDataFlow

Enumerator
eRender
eCapture
eAll

ERole

enum juce::ERole

Enumerator
eConsole
eMultimedia
eCommunications

InternalAccessibilityEvent

enum class juce::InternalAccessibilityEvent

strong

Enumerator
elementCreated
elementDestroyed
elementMovedOrResized
focusChanged
windowOpened
windowClosed

MessageBoxIconType

enum class juce::MessageBoxIconType

strong

The type of icon to show in the dialog box.

Enumerator
NoIcon	No icon will be shown on the dialog box.
QuestionIcon	A question-mark icon, for dialog boxes that need the user to answer a question.
WarningIcon	An exclamation mark to indicate that the dialog is a warning about something and shouldn't be ignored.
InfoIcon	An icon that indicates that the dialog box is just giving the user some information, which doesn't require a response from them.

Monitor_DPI_Type

enum juce::Monitor_DPI_Type

Enumerator
MDT_Effective_DPI
MDT_Angular_DPI
MDT_Raw_DPI
MDT_Default

NotificationType

enum juce::NotificationType

These enums are used in various classes to indicate whether a notification event should be sent out.

Enumerator
dontSendNotification	No notification message should be sent.
sendNotification	Requests a notification message, either synchronous or not.
sendNotificationSync	Requests a synchronous notification.
sendNotificationAsync	Requests an asynchronous notification.

POINTER_BUTTON_CHANGE_TYPE

enum juce::POINTER_BUTTON_CHANGE_TYPE

Enumerator
POINTER_CHANGE_NONE
POINTER_CHANGE_FIRSTBUTTON_DOWN
POINTER_CHANGE_FIRSTBUTTON_UP
POINTER_CHANGE_SECONDBUTTON_DOWN
POINTER_CHANGE_SECONDBUTTON_UP
POINTER_CHANGE_THIRDBUTTON_DOWN
POINTER_CHANGE_THIRDBUTTON_UP
POINTER_CHANGE_FOURTHBUTTON_DOWN
POINTER_CHANGE_FOURTHBUTTON_UP
POINTER_CHANGE_FIFTHBUTTON_DOWN
POINTER_CHANGE_FIFTHBUTTON_UP

VariantStreamMarkers

enum juce::VariantStreamMarkers

Enumerator
varMarker_Int
varMarker_BoolTrue
varMarker_BoolFalse
varMarker_Double
varMarker_String
varMarker_Int64
varMarker_Array
varMarker_Binary
varMarker_Undefined

WASAPIDeviceMode

enum class juce::WASAPIDeviceMode

strong

Available modes for the WASAPI audio device.

Pass one of these to the AudioIODeviceType::createAudioIODeviceType_WASAPI() method to create a WASAPI AudioIODeviceType object in this mode.

Enumerator
shared
exclusive
sharedLowLatency

Function Documentation

abs64()

int64 juce::abs64 ( int64 n )

inlinenoexcept

addAllSelectedItemIds()

void juce::addAllSelectedItemIds ( TreeViewItem * item, XmlElement & parent )

static

addAtomIfExists()

void juce::addAtomIfExists ( bool condition, const char * key, ::Display * display, std::vector< Atom > & atoms )

static

addBytesToPointer() [1/2]

template<typename Type, typename IntegerType>

const Type * juce::addBytesToPointer ( const Type * basePointer, IntegerType bytes )

inlinenoexcept

A handy function which adds a number of bytes to any type of pointer and returns the result. This can be useful to avoid casting pointers to a char* and back when you want to move them by a specific number of bytes,

addBytesToPointer() [2/2]

template<typename Type, typename IntegerType>

Type * juce::addBytesToPointer ( Type * basePointer, IntegerType bytes )

inlinenoexcept

A handy function which adds a number of bytes to any type of pointer and returns the result. This can be useful to avoid casting pointers to a char* and back when you want to move them by a specific number of bytes,

addHandlersToArray()

JUCE_COMRESULT juce::addHandlersToArray ( const std::vector< const AccessibilityHandler * > & handlers, SAFEARRAY ** pRetVal )

inline

addIfNotNull()

void juce::addIfNotNull ( OwnedArray< AudioIODeviceType > & list, AudioIODeviceType *const device )

static

addKeyPresses()

void juce::addKeyPresses ( KeyPressMappingSet & set, const ApplicationCommandInfo *const ci )

static

addPooledString()

template<typename NewStringType>

String juce::addPooledString ( Array< String > & strings, const NewStringType & newString )

static

appendToFile()

void juce::appendToFile ( const File & f, const String & s )

static

approximatelyEqual()

template<typename Type>

bool juce::approximatelyEqual ( Type a, Type b )

noexcept

Returns true if the two numbers are approximately equal. This is useful for floating-point and double comparisons.

areAnyAccessibilityClientsActive()

bool juce::areAnyAccessibilityClientsActive ( )

static

begin()

RangedDirectoryIterator juce::begin ( const RangedDirectoryIterator & it )

inline

Returns the iterator that was passed in. Provided for range-for compatibility.

blurDataTriplets()

void juce::blurDataTriplets ( uint8 * d, int num, const int delta )

staticnoexcept

blurSingleChannelImage() [1/2]

void juce::blurSingleChannelImage ( Image & image, int radius )

static

blurSingleChannelImage() [2/2]

void juce::blurSingleChannelImage ( uint8 *const data, const int width, const int height, const int lineStride, const int repetitions )

staticnoexcept

calcBufferStreamBufferSize()

int juce::calcBufferStreamBufferSize ( int requestedSize, InputStream * source )

staticnoexcept

calcCoefficient()

template<int k>

float juce::calcCoefficient ( float input, float offset )

staticnoexcept

callCPUID()

void juce::callCPUID ( int result[4], int infoType )

static

callOnMessageThread()

template<typename Callback>

void juce::callOnMessageThread

(

Callback &&

callback

)

canCompare()

bool juce::canCompare	(	const var &	v1,
		const var &	v2 )

canShowFolderForPlugin()

bool juce::canShowFolderForPlugin ( KnownPluginList & list, int index )

static

canUseMultiTouch()

bool juce::canUseMultiTouch ( )

static

castToCharPointer_wchar_t()

CharPointer_wchar_t juce::castToCharPointer_wchar_t ( const void * t )

staticnoexcept

castToSpinLockWithoutAliasingWarning()

SpinLock * juce::castToSpinLockWithoutAliasingWarning ( void * s )

static

checkFileExists()

File juce::checkFileExists ( const File & f )

static

checkFolderExists()

File juce::checkFolderExists ( const File & f )

static

checkForPointerAPI()

void juce::checkForPointerAPI ( )

static

clampPixelComponents()

uint32 juce::clampPixelComponents ( uint32 x )

inlinenoexcept

codeEditorMenuCallback()

void juce::codeEditorMenuCallback ( int menuResult, CodeEditorComponent * editor )

static

colourToD2D()

D2D1_COLOR_F juce::colourToD2D ( Colour c )

static

comboBoxPopupMenuFinishedCallback()

void juce::comboBoxPopupMenuFinishedCallback ( int result, ComboBox * combo )

static

compare()

int juce::compare ( const var & v1, const var & v2 )

static

compareFilenames()

int juce::compareFilenames ( const String & name1, const String & name2 )

staticnoexcept

compareStrings() [1/3]

int juce::compareStrings ( CharPointer_UTF8 s1, const String & s2 )

staticnoexcept

compareStrings() [2/3]

int juce::compareStrings ( const StartEndString & string1, const String & string2 )

staticnoexcept

compareStrings() [3/3]

int juce::compareStrings ( const String & s1, const String & s2 )

staticnoexcept

convertFixedToFloat()

void juce::convertFixedToFloat ( int *const * channels, int numChannels, int numSamples )

static

convertFloatsToInts()

void juce::convertFloatsToInts ( int * dest, const float * src, int numSamples )

staticnoexcept

convertLogicalScreenPointToPhysical()

Point< int > juce::convertLogicalScreenPointToPhysical ( Point< int > p, HWND h )

staticnoexcept

convertLogicalScreenRectangleToPhysical()

template<typename ValueType>

Rectangle< ValueType > juce::convertLogicalScreenRectangleToPhysical ( Rectangle< ValueType > r, HWND h )

staticnoexcept

convertPhysicalScreenPointToLogical()

Point< int > juce::convertPhysicalScreenPointToLogical ( Point< int > p, HWND h )

staticnoexcept

convertPhysicalScreenRectangleToLogical()

template<typename ValueType>

Rectangle< ValueType > juce::convertPhysicalScreenRectangleToLogical ( Rectangle< ValueType > r, HWND h )

staticnoexcept

copyColourIfSpecified()

void juce::copyColourIfSpecified ( Label & l, TextEditor & ed, int colourID, int targetColourID )

static

copyDrawableIfNotNull()

std::unique_ptr< Drawable > juce::copyDrawableIfNotNull ( const Drawable *const d )

static

countNumberOfBits() [1/2]

int juce::countNumberOfBits ( uint32 n )

inlinenoexcept

Returns the number of bits in a 32-bit integer.

countNumberOfBits() [2/2]

int juce::countNumberOfBits ( uint64 n )

inlinenoexcept

Returns the number of bits in a 64-bit integer.

countNumberOfSeparators()

int juce::countNumberOfSeparators ( String::CharPointerType s )

static

countUsedClientChannels()

int juce::countUsedClientChannels ( const std::vector< DynamicChannelMapping > & inputMap, const std::vector< DynamicChannelMapping > & outputMap )

inlinestatic

countValidBuses()

template<typename FloatType>

int juce::countValidBuses ( Steinberg::Vst::AudioBusBuffers * buffers, int32 num )

static

createAudioIODeviceType_ALSA_PCMDevices()

AudioIODeviceType * juce::createAudioIODeviceType_ALSA_PCMDevices ( )

inlinestatic

createAudioIODeviceType_ALSA_Soundcards()

AudioIODeviceType * juce::createAudioIODeviceType_ALSA_Soundcards ( )

inlinestatic

createCopyIfNotNull()

template<class Type>

Type * juce::createCopyIfNotNull ( const Type * objectToCopy )

inline

If a pointer is non-null, this returns a new copy of the object that it points to, or safely returns nullptr if the pointer is null.

createDraggingHandCursor() [1/2]

Cursor juce::createDraggingHandCursor ( )

static

createDraggingHandCursor() [2/2]

Cursor juce::createDraggingHandCursor ( )

static

createDrawableFromImage()

std::unique_ptr< Drawable > juce::createDrawableFromImage ( const Image & im )

static

createDrawableFromSVG()

std::unique_ptr< Drawable > juce::createDrawableFromSVG ( const char * data )

static

createMessageBox()

std::unique_ptr< WindowsMessageBoxBase > juce::createMessageBox ( const MessageBoxOptions & options, std::unique_ptr< ModalComponentManager::Callback > callback )

static

createNonRepaintingEmbeddedWindowsPeer()

JUCE_API ComponentPeer * juce::createNonRepaintingEmbeddedWindowsPeer	(	Component &	component,
		void *	parentHWND )

createNSArrayFromStringArray()

NSArray * juce::createNSArrayFromStringArray ( const StringArray & strings )

inline

createNSMenu()

NSMenu * juce::createNSMenu ( const PopupMenu & , const String & name, int topLevelMenuId, int topLevelIndex, bool addDelegate )

extern

createNSObjectFromJuceClass()

template<typename Class>

NSObject * juce::createNSObjectFromJuceClass

(

Class *

obj

)

createNSURLFromFile() [1/2]

NSURL * juce::createNSURLFromFile ( const File & f )

inline

createNSURLFromFile() [2/2]

NSURL * juce::createNSURLFromFile ( const String & f )

inline

CreateObjCBlock()

template<typename ReturnT, class Class, typename... Params>

ReturnT(^)(Params...) juce::CreateObjCBlock	(	Class *	object,
		ReturnT(Class::*	fn )(Params...) )

createPathFromData()

Path juce::createPathFromData ( float height, const unsigned char * data, size_t size )

static

createSnapshotOfNativeWindow()

Image juce::createSnapshotOfNativeWindow

(

void *

nativeWindowHandle

)

createTempFile()

File juce::createTempFile ( const File & parentDirectory, String name, const String & suffix, int optionFlags )

static

degreesToRadians()

template<typename FloatType>

FloatType juce::degreesToRadians ( FloatType degrees )

constexprnoexcept

Converts an angle in degrees to radians.

deleteAndZero() [1/2]

template<typename Type>

void juce::deleteAndZero

(

ScopedPointer< Type > &

)

deleteAndZero() [2/2]

template<typename Type>

void juce::deleteAndZero ( Type & pointer )

inline

Delete an object pointer, and sets the pointer to null.

Remember that it's not good c++ practice to use delete directly - always try to use a std::unique_ptr or other automatic lifetime-management system rather than resorting to deleting raw pointers!

deleteKeyNonRecursive()

bool juce::deleteKeyNonRecursive ( const String & regKeyPath, WindowsRegistry::WoW64Mode mode )

static

describeDays()

String juce::describeDays ( int n )

static

describeHours()

String juce::describeHours ( int n )

static

describeMinutes()

String juce::describeMinutes ( int n )

static

describeMonths()

String juce::describeMonths ( int n )

static

describeSeconds()

String juce::describeSeconds ( int n )

static

describeWeeks()

String juce::describeWeeks ( int n )

static

describeYears()

String juce::describeYears ( int n )

static

deviceListContains()

bool juce::deviceListContains ( AudioIODeviceType * type, bool isInput, const String & name )

static

dispatchNextMessageOnSystemQueue()

bool juce::dispatchNextMessageOnSystemQueue

(

bool

returnIfNoPendingMessages

)

doUIDsMatch()

bool juce::doUIDsMatch ( const Steinberg::TUID a, const Steinberg::TUID b )

inlinenoexcept

drawButtonShape()

void juce::drawButtonShape ( Graphics & g, const Path & outline, Colour baseColour, float height )

static

drawGlyphWithFont()

void juce::drawGlyphWithFont ( Graphics & g, int glyph, const Font & font, AffineTransform t )

static

drawShadowSection()

void juce::drawShadowSection ( Graphics & g, ColourGradient & cg, Rectangle< float > area, bool isCorner, float centreX, float centreY, float edgeX, float edgeY )

static

drawTriangle()

void juce::drawTriangle ( Graphics & g, float x1, float y1, float x2, float y2, float x3, float y3, Colour fill, Colour outline )

static

end()

RangedDirectoryIterator juce::end ( const RangedDirectoryIterator & )

inline

Returns a default-constructed sentinel value. Provided for range-for compatibility.

enumAlwaysOnTopWindows()

BOOL CALLBACK juce::enumAlwaysOnTopWindows ( HWND hwnd, LPARAM lParam )

static

enumMonitorsProc()

BOOL CALLBACK juce::enumMonitorsProc ( HMONITOR hm, HDC , LPRECT , LPARAM userInfo )

static

escapeSlashesInTreeViewItemName()

String juce::escapeSlashesInTreeViewItemName ( const String & s )

static

extractFileHICON()

HICON juce::extractFileHICON ( const File & file )

static

findByteOffsetOfEnd()

size_t juce::findByteOffsetOfEnd ( String::CharPointerType text )

staticnoexcept

findCentralDirectoryFileHeader()

int64 juce::findCentralDirectoryFileHeader ( InputStream & input, int & numEntries )

static

findContainer()

template<typename FocusContainerFn>

Component * juce::findContainer ( const Component * child, FocusContainerFn isFocusContainer )

static

findDefaultDeviceIndex()

int juce::findDefaultDeviceIndex ( const Array< MidiDeviceInfo > & available, const MidiDeviceInfo & defaultDevice )

static

findEnclosingHandler()

AccessibilityHandler * juce::findEnclosingHandler ( Component * comp )

static

findFirstEnabledAncestor()

Component * juce::findFirstEnabledAncestor ( Component * in )

static

findFirstUnignoredChild()

AccessibilityHandler * juce::findFirstUnignoredChild ( const std::vector< AccessibilityHandler * > & handlers )

static

findFontsConfFile()

std::unique_ptr< XmlElement > juce::findFontsConfFile ( )

static

findHighestSetBit()

int juce::findHighestSetBit ( uint32 n )

noexcept

Returns the index of the highest set bit in a (non-zero) number. So for n=3 this would return 1, for n=7 it returns 2, etc. An input value of 0 is illegal!

findInsertIndexInSortedArray()

template<class ElementType, class ElementComparator>

int juce::findInsertIndexInSortedArray ( ElementComparator & comparator, ElementType *const array, const ElementType newElement, int firstElement, int lastElement )

static

Searches a sorted array of elements, looking for the index at which a specified value should be inserted for it to be in the correct order.

The comparator object that is passed-in must define a public method with the following signature:

int compareElements (ElementType first, ElementType second);

..and this method must return:

• a value of < 0 if the first comes before the second
• a value of 0 if the two objects are equivalent
• a value of > 0 if the second comes before the first

To improve performance, the compareElements() method can be declared as static or const.

Parameters

comparator	an object which defines a compareElements() method
array	the array to search
newElement	the value that is going to be inserted
firstElement	the index of the first element to search
lastElement	the index of the last element in the range (this is non-inclusive)

findMaximum()

template<typename Type, typename Size>

Type juce::findMaximum	(	const Type *	values,
		Size	numValues )

Scans an array of values, returning the maximum value that it contains.

findMinAndMax()

template<typename Type>

void juce::findMinAndMax	(	const Type *	values,
		int	numValues,
		Type &	lowest,
		Type &	highest )

Scans an array of values, returning the minimum and maximum values that it contains.

findMinimum()

template<typename Type, typename Size>

Type juce::findMinimum	(	const Type *	data,
		Size	numValues )

Scans an array of values, returning the minimum value that it contains.

findNumberOfPhysicalCores()

int juce::findNumberOfPhysicalCores ( )

staticnoexcept

findTrimmedEnd()

String::CharPointerType juce::findTrimmedEnd ( const String::CharPointerType start, String::CharPointerType end )

static

getAccessibleApplicationOrPluginName()

String juce::getAccessibleApplicationOrPluginName ( )

inline

getAddressDifference()

template<typename Type1, typename Type2>

int juce::getAddressDifference ( Type1 * pointer1, Type2 * pointer2 )

inlinenoexcept

A handy function which returns the difference between any two pointers, in bytes. The address of the second pointer is subtracted from the first, and the difference in bytes is returned.

getAllEventsMask()

int juce::getAllEventsMask ( bool ignoresMouseClicks )

static

getArrangementForBus()

Steinberg::Vst::SpeakerArrangement juce::getArrangementForBus ( Steinberg::Vst::IAudioProcessor * processor, bool isInput, int busIndex )

inlinestatic

getAudioBusPointer() [1/2]

auto & juce::getAudioBusPointer ( detail::Tag< double > , Steinberg::Vst::AudioBusBuffers & data )

inline

getAudioBusPointer() [2/2]

auto & juce::getAudioBusPointer ( detail::Tag< float > , Steinberg::Vst::AudioBusBuffers & data )

inline

getAutomationId()

String juce::getAutomationId ( const AccessibilityHandler & handler )

static

getChannelName()

String juce::getChannelName ( const OwnedArray< AudioProcessor::Bus > & buses, int index )

static

getChannelSetForSpeakerArrangement()

AudioChannelSet juce::getChannelSetForSpeakerArrangement ( Steinberg::Vst::SpeakerArrangement arr )

inlinenoexcept

getChannelType()

AudioChannelSet::ChannelType juce::getChannelType ( Steinberg::Vst::SpeakerArrangement arr, Steinberg::Vst::Speaker type )

staticnoexcept

getCharacterType()

int juce::getCharacterType ( juce_wchar character )

staticnoexcept

getClassName()

constexpr auto juce::getClassName ( AccessibilityRole role )

staticconstexpr

getCommandLinePrefix()

String juce::getCommandLinePrefix ( const String & commandLineUniqueID )

static

getCpuInfo()

String juce::getCpuInfo ( const char * key )

static

getCPUInformation()

const CPUInformation & juce::getCPUInformation ( )

staticnoexcept

getCurrentDisplayFromScaleFactor()

const Displays::Display * juce::getCurrentDisplayFromScaleFactor ( HWND hwnd )

static

getCurrentThreadHolder()

CurrentThreadHolder::Ptr juce::getCurrentThreadHolder ( )

static

getDefaultPasswordChar()

juce_wchar juce::getDefaultPasswordChar ( )

staticnoexcept

getDeletedAtShutdownObjects()

Array< DeletedAtShutdown * > & juce::getDeletedAtShutdownObjects ( )

static

getEdgeTableAllocationSize()

size_t juce::getEdgeTableAllocationSize ( int lineStride, int height )

staticnoexcept

getEmptyStringRef()

const String & juce::getEmptyStringRef ( )

staticnoexcept

getEventTime() [1/2]

int64 juce::getEventTime ( ::Time t )

static

getEventTime() [2/2]

template<typename EventType>

int64 juce::getEventTime ( const EventType & t )

static

getExeNameAndArgs()

String juce::getExeNameAndArgs ( const ArgumentList & args, const ConsoleApplication::Command & command )

static

getFirstUnignoredDescendant()

AccessibilityHandler * juce::getFirstUnignoredDescendant ( AccessibilityHandler * handler )

static

getFontPlaceholderNames()

const FontPlaceholderNames & juce::getFontPlaceholderNames ( )

static

getGlobalDPI()

double juce::getGlobalDPI ( )

static

getIconFromApplication()

Image JUCE_API juce::getIconFromApplication	(	const String &	applicationPath,
		const int	size )

getIconFromIcnsFile()

Image juce::getIconFromIcnsFile ( const File & icnsFile, const int size )

static

getItemDepth()

int juce::getItemDepth ( const TreeViewItem * item )

static

getIvar()

template<typename Type>

Type juce::getIvar ( id self, const char * name )

inline

getJuceClassFromNSObject()

template<typename Class>

Class * juce::getJuceClassFromNSObject

(

NSObject *

obj

)

getListRowAccessibilityActions()

template<typename RowComponentType>

AccessibilityActions juce::getListRowAccessibilityActions ( RowComponentType & rowComponent )

static

getLocaleValue() [1/2]

String juce::getLocaleValue ( LCID locale, LCTYPE key, const char * defaultValue )

static

getLocaleValue() [2/2]

String juce::getLocaleValue ( nl_item key )

static

getLogicalMousePos()

template<typename EventType>

Point< float > juce::getLogicalMousePos ( const EventType & e, double scaleFactor )

staticnoexcept

getLogoArea()

Rectangle< float > juce::getLogoArea ( Rectangle< float > parentRect )

static

getMatches()

StringArray juce::getMatches ( const String & toMatch, const char *MimeTypeTableEntry::* matchField, const char *MimeTypeTableEntry::* returnField )

static

getMonthNumberForCompileDate()

int juce::getMonthNumberForCompileDate ( const String & m )

static

getMouseEventTime()

int64 juce::getMouseEventTime

(

)

getNullVarRef() [1/2]

const var & juce::getNullVarRef ( )

staticnoexcept

getNullVarRef() [2/2]

const var & juce::getNullVarRef ( )

staticnoexcept

getPeerFor()

ComponentPeer * juce::getPeerFor

(

::Window

windowH

)

getPeerForDragEvent()

LinuxComponentPeer * juce::getPeerForDragEvent ( Component * sourceComp )

static

getPluginDescSuffix()

String juce::getPluginDescSuffix ( const PluginDescription & d, int uid )

static

getProcess()

DWORD juce::getProcess ( HWND hwnd )

static

getProviderWithCheckedWrapper()

template<typename Callback>

void juce::getProviderWithCheckedWrapper	(	const AccessibilityHandler &	handler,
		Callback &&	callback )

getScaleFactorForWindow()

JUCE_API double juce::getScaleFactorForWindow

(

HWND

h

)

getSetupInfo()

template<typename Setup>

auto juce::getSetupInfo ( Setup & s, bool isInput )

static

getSourceView()

jobject juce::getSourceView ( const AccessibilityHandler & handler )

static

getSpeakerOrder()

Array< AudioChannelSet::ChannelType > juce::getSpeakerOrder ( Steinberg::Vst::SpeakerArrangement arr )

static

getSpeakerType()

Steinberg::Vst::Speaker juce::getSpeakerType ( const AudioChannelSet & set, AudioChannelSet::ChannelType type )

staticnoexcept

getStepSize()

double juce::getStepSize ( const Slider & slider )

static

getStringFromWindows1252Codepage()

String juce::getStringFromWindows1252Codepage ( const char * data, size_t num )

static

getTypefaceForFontFromLookAndFeel()

Typeface::Ptr juce::getTypefaceForFontFromLookAndFeel ( const Font & font )

static

getUnignoredAncestor()

AccessibilityHandler * juce::getUnignoredAncestor ( AccessibilityHandler * handler )

static

getUser32Function()

void * juce::getUser32Function

(

const char *

)

getValueWithDefault()

auto juce::getValueWithDefault ( const StringMap & m, const String & key, const String & fallback = {} )

static

getVst3SpeakerArrangement()

Steinberg::Vst::SpeakerArrangement juce::getVst3SpeakerArrangement ( const AudioChannelSet & channels )

staticnoexcept

getWindowClientRect()

RECT juce::getWindowClientRect ( HWND hwnd )

static

getWindowScreenRect()

RECT juce::getWindowScreenRect ( HWND hwnd )

static

getWindowsVersionInfo()

RTL_OSVERSIONINFOW juce::getWindowsVersionInfo ( )

extern

getWorkArea()

Rectangle< int > juce::getWorkArea ( const XWindowSystemUtilities::GetXProperty & prop )

static

handleCrash()

void juce::handleCrash ( int signum )

static

hasEffectiveRootFilePermissions()

bool juce::hasEffectiveRootFilePermissions ( )

static

hasSymbolicPart()

bool juce::hasSymbolicPart ( const File & root, const File & f )

static

hasWorkAreaData()

bool juce::hasWorkAreaData ( const XWindowSystemUtilities::GetXProperty & prop )

static

hexToString()

template<typename Type>

String juce::hexToString ( Type v )

static

ignoreUnused()

template<typename... Types>

void juce::ignoreUnused ( Types && ... )

noexcept

Handy function for avoiding unused variables warning.

initialiseJuce_GUI()

JUCE_API void JUCE_CALLTYPE juce::initialiseJuce_GUI

(

)

Initialises JUCE's GUI classes.

If you're embedding JUCE into an application that uses its own event-loop rather than using the START_JUCE_APPLICATION macro, call this function before making any JUCE calls, to make sure things are initialised correctly.

Note that if you're creating a JUCE DLL for Windows, you may also need to call the Process::setCurrentModuleInstanceHandle() method.

See also

shutdownJuce_GUI()

isBreakableGlyph()

bool juce::isBreakableGlyph ( const PositionedGlyph & g )

staticnoexcept

isComponentVisibleWithinParent()

bool juce::isComponentVisibleWithinParent ( Component * comp )

static

isComponentVisibleWithinWindow()

bool juce::isComponentVisibleWithinWindow ( const Component & comp )

static

isEmbeddedInForegroundProcess()

bool juce::isEmbeddedInForegroundProcess

(

Component *

c

)

isFileExecutable()

bool juce::isFileExecutable ( const String & filename )

static

isForegroundOrEmbeddedProcess()

bool juce::isForegroundOrEmbeddedProcess ( Component * viewComponent )

static

isHandlerValid()

bool juce::isHandlerValid ( const AccessibilityHandler & handler )

static

isLayoutTableValid()

bool juce::isLayoutTableValid ( )

inline

isLeftRightKeyPress()

bool juce::isLeftRightKeyPress ( const KeyPress & key )

static

isLongOptionFormat()

bool juce::isLongOptionFormat ( StringRef s )

static

isMarker()

bool juce::isMarker ( float value, float marker )

staticnoexcept

isMessageType()

bool juce::isMessageType ( const MemoryBlock & mb, const char * messageType )

staticnoexcept

isNonBreakingSpace()

constexpr bool juce::isNonBreakingSpace ( const juce_wchar c )

staticconstexpr

isOptionFormat()

bool juce::isOptionFormat ( StringRef s )

static

isPerMonitorDPIAwareProcess()

bool juce::isPerMonitorDPIAwareProcess ( )

static

isPerMonitorDPIAwareThread()

bool juce::isPerMonitorDPIAwareThread ( GetThreadDPIAwarenessContextFunc getThreadDPIAwarenessContextIn = getThreadDPIAwarenessContext, GetAwarenessFromDpiAwarenessContextFunc getAwarenessFromDPIAwarenessContextIn = getAwarenessFromDPIAwarenessContext )

static

isPerMonitorDPIAwareWindow()

bool juce::isPerMonitorDPIAwareWindow ( HWND nativeWindow )

static

isPositiveAndBelow() [1/2]

template<typename Type>

bool juce::isPositiveAndBelow ( int valueToTest, Type upperLimit )

noexcept

isPositiveAndBelow() [2/2]

template<typename Type1, typename Type2>

bool juce::isPositiveAndBelow ( Type1 valueToTest, Type2 upperLimit )

noexcept

Returns true if a value is at least zero, and also below a specified upper limit. This is basically a quicker way to write:

valueToTest >= 0 && valueToTest < upperLimit

isPositiveAndNotGreaterThan() [1/2]

template<typename Type>

bool juce::isPositiveAndNotGreaterThan ( int valueToTest, Type upperLimit )

noexcept

isPositiveAndNotGreaterThan() [2/2]

template<typename Type1, typename Type2>

bool juce::isPositiveAndNotGreaterThan ( Type1 valueToTest, Type2 upperLimit )

noexcept

Returns true if a value is at least zero, and also less than or equal to a specified upper limit. This is basically a quicker way to write:

valueToTest >= 0 && valueToTest <= upperLimit

isPowerOfTwo()

template<typename IntegerType>

bool juce::isPowerOfTwo ( IntegerType value )

constexpr

Returns true if the specified integer is a power-of-two.

isQuoteCharacter()

bool juce::isQuoteCharacter ( juce_wchar c )

staticnoexcept

isShortOptionFormat()

bool juce::isShortOptionFormat ( StringRef s )

static

isStartingUpOrShuttingDown()

bool juce::isStartingUpOrShuttingDown ( )

static

isStereoPair()

bool juce::isStereoPair ( const OwnedArray< AudioProcessor::Bus > & buses, int index )

static

isUpDownKeyPress()

bool juce::isUpDownKeyPress ( const KeyPress & key )

static

isValidXmlNameBodyCharacter()

bool juce::isValidXmlNameBodyCharacter ( juce_wchar character )

staticnoexcept

isValidXmlNameStartCharacter()

bool juce::isValidXmlNameStartCharacter ( juce_wchar character )

staticnoexcept

isWindowOnCurrentVirtualDesktop()

bool juce::isWindowOnCurrentVirtualDesktop

(

void *

)

isWithin()

template<typename Type>

bool juce::isWithin ( Type a, Type b, Type tolerance )

noexcept

Computes the absolute difference between two values and returns true if it is less than or equal to a given tolerance, otherwise it returns false.

jlimit()

template<typename Type>

Type juce::jlimit ( Type lowerLimit, Type upperLimit, Type valueToConstrain )

noexcept

Constrains a value to keep it within a given range.

This will check that the specified value lies between the lower and upper bounds specified, and if not, will return the nearest value that would be in-range. Effectively, it's like calling jmax (lowerLimit, jmin (upperLimit, value)).

Note that it expects that lowerLimit <= upperLimit. If this isn't true, the results will be unpredictable.

Parameters

lowerLimit	the minimum value to return
upperLimit	the maximum value to return
valueToConstrain	the value to try to return

Returns

the closest value to valueToConstrain which lies between lowerLimit and upperLimit (inclusive)

See also

jmin, jmax, jmap

jmap() [1/2]

template<typename Type>

Type juce::jmap	(	Type	sourceValue,
		Type	sourceRangeMin,
		Type	sourceRangeMax,
		Type	targetRangeMin,
		Type	targetRangeMax )

Remaps a value from a source range to a target range.

jmap() [2/2]

template<typename Type>

Type juce::jmap ( Type value0To1, Type targetRangeMin, Type targetRangeMax )

constexpr

Remaps a normalised value (between 0 and 1) to a target range. This effectively returns (targetRangeMin + value0To1 * (targetRangeMax - targetRangeMin)).

jmax() [1/4]

template<typename Type>

dsp::SIMDRegister< Type > JUCE_VECTOR_CALLTYPE juce::jmax ( dsp::SIMDRegister< Type > a, dsp::SIMDRegister< Type > b )

inline

jmax() [2/4]

template<typename Type>

Type juce::jmax ( Type a, Type b )

constexpr

Returns the larger of two values.

jmax() [3/4]

template<typename Type>

Type juce::jmax ( Type a, Type b, Type c )

constexpr

Returns the larger of three values.

jmax() [4/4]

template<typename Type>

Type juce::jmax ( Type a, Type b, Type c, Type d )

constexpr

Returns the larger of four values.

jmin() [1/4]

template<typename Type>

dsp::SIMDRegister< Type > JUCE_VECTOR_CALLTYPE juce::jmin ( dsp::SIMDRegister< Type > a, dsp::SIMDRegister< Type > b )

inline

jmin() [2/4]

template<typename Type>

Type juce::jmin ( Type a, Type b )

constexpr

Returns the smaller of two values.

jmin() [3/4]

template<typename Type>

Type juce::jmin ( Type a, Type b, Type c )

constexpr

Returns the smaller of three values.

jmin() [4/4]

template<typename Type>

Type juce::jmin ( Type a, Type b, Type c, Type d )

constexpr

Returns the smaller of four values.

juce_areThereAnyAlwaysOnTopWindows()

bool juce::juce_areThereAnyAlwaysOnTopWindows

(

)

juce_checkCurrentlyFocusedTopLevelWindow()

void juce::juce_checkCurrentlyFocusedTopLevelWindow

(

)

JUCE_COMCLASS()

juce::JUCE_COMCLASS	(	MMDeviceEnumerator	,
		"BCDE0395-E52F-467C-8E3D-C4579291692E"	)

juce_createCoreGraphicsImage()

CGImageRef juce::juce_createCoreGraphicsImage	(	const Image &	,
		CGColorSpaceRef	)

juce_createIconForFile()

Image juce::juce_createIconForFile

(

const File &

file

)

juce_createKeyProxyWindow()

Window juce::juce_createKeyProxyWindow

(

ComponentPeer *

peer

)

JUCE_DECL_JACK_FUNCTION() [1/11]

jack_client_t client juce::JUCE_DECL_JACK_FUNCTION	(	int	,
		jack_activate	,
		(jack_client_t *client)	,
		(client)	)

JUCE_DECL_JACK_FUNCTION() [2/11]

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags juce::JUCE_DECL_JACK_FUNCTION	(	int	,
		jack_connect	,
		(jack_client_t *client, const char *source_port, const char *destination_port)	,
		(client, source_port, destination_port)	) const

JUCE_DECL_JACK_FUNCTION() [3/11]

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port jack_client_t jack_port_id_t port_id juce::JUCE_DECL_JACK_FUNCTION	(	int	,
		jack_port_connected	,
		(const jack_port_t *port)	,
		(port)	)

JUCE_DECL_JACK_FUNCTION() [4/11]

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func juce::JUCE_DECL_JACK_FUNCTION	(	int	,
		jack_set_process_callback	,
		(jack_client_t *client, JackProcessCallback process_callback, void *arg)	,
		(client, process_callback, arg)	) const

JUCE_DECL_JACK_FUNCTION() [5/11]

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port jack_client_t jack_port_id_t port_id const jack_port_t const char port_name juce::JUCE_DECL_JACK_FUNCTION	(	int	,
		jack_set_xrun_callback	,
		(jack_client_t *client, JackXRunCallback xrun_callback, void *arg)	,
		(client, xrun_callback, arg)	)

JUCE_DECL_JACK_FUNCTION() [6/11]

juce::JUCE_DECL_JACK_FUNCTION	(	jack_client_t *	,
		jack_client_open	,
		(const char *client_name, jack_options_t options, jack_status_t *status,...)	,
		(client_name, options, status)	)

JUCE_DECL_JACK_FUNCTION() [7/11]

jack_client_t client jack_client_t client juce::JUCE_DECL_JACK_FUNCTION	(	jack_nframes_t	,
		jack_get_buffer_size	,
		(jack_client_t *client)	,
		(client)	)

JUCE_DECL_JACK_FUNCTION() [8/11]

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port jack_client_t jack_port_id_t port_id const jack_port_t const char port_name const jack_port_t port juce::JUCE_DECL_JACK_FUNCTION	(	jack_port_t *	,
		jack_port_by_name	,
		(jack_client_t *client, const char *name)	,
		(client, name)	)

JUCE_DECL_JACK_FUNCTION() [9/11]

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port juce::JUCE_DECL_JACK_FUNCTION	(	jack_port_t *	,
		jack_port_register	,
		(jack_client_t *client, const char *port_name, const char *port_type, unsigned long flags, unsigned long buffer_size)	,
		(client, port_name, port_type, flags, buffer_size)	)

JUCE_DECL_JACK_FUNCTION() [10/11]

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg juce::JUCE_DECL_JACK_FUNCTION	(	void *	,
		jack_port_get_buffer	,
		(jack_port_t *port, jack_nframes_t nframes)	,
		(port, nframes)	)

JUCE_DECL_JACK_FUNCTION() [11/11]

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port juce::JUCE_DECL_JACK_FUNCTION	(	void *	,
		jack_set_port_connect_callback	,
		(jack_client_t *client, JackPortConnectCallback connect_callback, void *arg)	,
		(client, connect_callback, arg)	)

JUCE_DECL_VOID_JACK_FUNCTION()

jack_client_t client jack_client_t client jack_client_t client juce::JUCE_DECL_VOID_JACK_FUNCTION	(	jack_on_shutdown	,
		(jack_client_t *client, void(*function)(void *arg), void *arg)	,
		(client, function, arg)	)

juce_deleteKeyProxyWindow()

void juce::juce_deleteKeyProxyWindow

(

::Window

keyProxy

)

juce_fileSetPosition()

int64 juce::juce_fileSetPosition	(	void *	handle,
		int64	pos )

juce_getClockCycleCounter()

int64 juce::juce_getClockCycleCounter ( )

staticnoexcept

juce_getCurrentFocusWindow()

unsigned long juce::juce_getCurrentFocusWindow

(

ComponentPeer *

peer

)

juce_getExecutableFile()

File juce::juce_getExecutableFile

(

)

juce_getImageContext()

CGContextRef juce::juce_getImageContext

(

const Image &

)

juce_getOutputFromCommand()

String juce::juce_getOutputFromCommand

(

const String &

command

)

juce_gtkWebkitMain()

int juce::juce_gtkWebkitMain ( int argc, const char * argv[] )

extern

juce_handleXEmbedEvent()

bool juce::juce_handleXEmbedEvent	(	ComponentPeer *	p,
		void *	e )

juce_hypot() [1/2]

template<>

float juce::juce_hypot ( float a, float b )

inlinenoexcept

juce_hypot() [2/2]

template<typename Type>

Type juce::juce_hypot ( Type a, Type b )

noexcept

Using juce_hypot is easier than dealing with the different types of hypot function that are provided by the various platforms and compilers.

juce_isfinite() [1/3]

template<>

bool juce::juce_isfinite ( double value )

inlinenoexcept

juce_isfinite() [2/3]

template<>

bool juce::juce_isfinite ( float value )

inlinenoexcept

juce_isfinite() [3/3]

template<typename NumericType>

bool juce::juce_isfinite ( NumericType )

noexcept

The isfinite() method seems to vary between platforms, so this is a platform-independent function for it.

juce_isRunningInWine()

bool juce::juce_isRunningInWine

(

)

juce_isRunningUnderDebugger()

JUCE_API bool JUCE_CALLTYPE juce::juce_isRunningUnderDebugger ( )

externnoexcept

JUCE_IUNKNOWNCLASS() [1/12]

JUCE_COMCLASS(IAudioClient2, "726778CD-F60A-4eda-82DE-E47610CD78AA") JUCE_COMCLASS(IAudioClient3, "1CB9AD4C-DBFA-4c32-B178-C2F568A703B2") juce::JUCE_IUNKNOWNCLASS	(	IAudioCaptureClient	,
		"C8ADBD64-E71E-48a0-A4DE-185C395CD317"	)

JUCE_IUNKNOWNCLASS() [2/12]

juce::JUCE_IUNKNOWNCLASS	(	IAudioClient	,
		"1CB9AD4C-DBFA-4c32-B178-C2F568A703B2"	)

JUCE_IUNKNOWNCLASS() [3/12]

juce::JUCE_IUNKNOWNCLASS	(	IAudioEndpointVolume	,
		"5CDF2C82-841E-4546-9722-0CF74078229A"	)

JUCE_IUNKNOWNCLASS() [4/12]

juce::JUCE_IUNKNOWNCLASS	(	IAudioRenderClient	,
		"F294ACFC-3146-4483-A7BF-ADDCA7C260E2"	)

JUCE_IUNKNOWNCLASS() [5/12]

juce::JUCE_IUNKNOWNCLASS	(	IAudioSessionControl	,
		"F4B1A599-7266-4319-A8CA-E70ACB11E8CD"	)

JUCE_IUNKNOWNCLASS() [6/12]

juce::JUCE_IUNKNOWNCLASS	(	IAudioSessionEvents	,
		"24918ACC-64B3-37C1-8CA9-74A66E9957A8"	)

JUCE_IUNKNOWNCLASS() [7/12]

juce::JUCE_IUNKNOWNCLASS	(	IMMDevice	,
		"D666063F-1587-4E43-81F1-B948E807363F"	)

JUCE_IUNKNOWNCLASS() [8/12]

juce::JUCE_IUNKNOWNCLASS	(	IMMDeviceEnumerator	,
		"A95664D2-9614-4F35-A746-DE8DB63617E6"	)

JUCE_IUNKNOWNCLASS() [9/12]

juce::JUCE_IUNKNOWNCLASS	(	IMMEndpoint	,
		"1BE09788-6894-4089-8586-9A2A6C265AC5"	)

JUCE_IUNKNOWNCLASS() [10/12]

juce::JUCE_IUNKNOWNCLASS	(	IMMNotificationClient	,
		"7991EEC9-7E89-4D85-8390-6C703CEC60C0"	)

JUCE_IUNKNOWNCLASS() [11/12]

juce::JUCE_IUNKNOWNCLASS	(	IPropertyStore	,
		"886d8eeb-8cf2-4446-8d02-cdba1dbdcf99"	)

JUCE_IUNKNOWNCLASS() [12/12]

juce::JUCE_IUNKNOWNCLASS	(	ITipInvocation	,
		"37c994e7-432b-4834-a2f7-dce1f13b834b"	)

juce_LinuxAddRepaintListener()

void juce::juce_LinuxAddRepaintListener	(	ComponentPeer *	peer,
		Component *	dummy )

juce_LinuxRemoveRepaintListener()

void juce::juce_LinuxRemoveRepaintListener	(	ComponentPeer *	peer,
		Component *	dummy )

juce_loadJackFunction()

void * juce::juce_loadJackFunction ( const char *const name )

static

juce_millisecondsSinceStartup()

uint32 juce::juce_millisecondsSinceStartup ( )

noexcept

juce_offerEventToActiveXControl()

LRESULT juce::juce_offerEventToActiveXControl

(

::MSG &

msg

)

juce_performDragDropFiles()

bool juce::juce_performDragDropFiles	(	const StringArray &	,
		const bool	copyFiles,
		bool &	shouldStop )

juce_performDragDropText()

bool juce::juce_performDragDropText	(	const String &	,
		bool &	shouldStop )

juce_repeatLastProcessPriority()

void juce::juce_repeatLastProcessPriority

(

)

juce_runSystemCommand()

void juce::juce_runSystemCommand

(

const String &

command

)

juce_siginterrupt()

int juce::juce_siginterrupt	(	int	sig,
		int	flag )

juce_threadEntryPoint()

void JUCE_API juce::juce_threadEntryPoint

(

void *

userData

)

juceRangeToNS()

NSRange juce::juceRangeToNS ( Range< int > range )

inline

juceStringToNS()

NSString * juce::juceStringToNS ( const String & s )

inline

loadDPIAwarenessFunctions()

void juce::loadDPIAwarenessFunctions ( )

static

loadSDKDependentMethods()

void juce::loadSDKDependentMethods ( )

static

logAssertion()

JUCE_API void JUCE_CALLTYPE juce::logAssertion ( const char * file, int line )

externnoexcept

makeARASizedStruct()

template<typename Obj, typename Member, typename... Ts>

Obj juce::makeARASizedStruct ( Member Obj::* member, Ts &&... ts )

constexpr

makeAttachment()

template<typename Attachment, typename Control>

std::unique_ptr< Attachment > juce::makeAttachment	(	const AudioProcessorValueTreeState &	stateToUse,
		const String &	parameterID,
		Control &	control )

makeMouseEvent()

auto juce::makeMouseEvent ( MouseInputSource source, const PointerState & ps, ModifierKeys modifiers, Component * eventComponent, Component * originator, Time eventTime, Point< float > mouseDownPos, Time mouseDownTime, int numberOfClicks, bool mouseWasDragged )

inline

makeOptional()

template<typename Value>

JUCE_END_IGNORE_WARNINGS_MSVC Optional< std::decay_t< Value > > juce::makeOptional

(

Value &&

v

)

mapFromLog10()

template<typename Type>

Type juce::mapFromLog10	(	Type	valueInLogRange,
		Type	logRangeMin,
		Type	logRangeMax )

Remaps a logarithmic value in a target range to a normalised value (between 0 and 1).

The entire target range must be greater than zero.

See also

mapToLog10

mapFromLog10 (4.0, 0.4, 40.0) == 0.5

mapToLog10()

template<typename Type>

Type juce::mapToLog10	(	Type	value0To1,
		Type	logRangeMin,
		Type	logRangeMax )

Remaps a normalised value (between 0 and 1) to a logarithmic target range.

The entire target range must be greater than zero.

See also

mapFromLog10

mapToLog10 (0.5, 0.4, 40.0) == 4.0

maskPixelComponents()

uint32 juce::maskPixelComponents ( uint32 x )

inlinenoexcept

matchWildcard()

bool juce::matchWildcard ( const File & file, const StringArray & wildcards )

static

naturalStringCompare()

int juce::naturalStringCompare ( String::CharPointerType s1, String::CharPointerType s2, bool isCaseSensitive )

staticnoexcept

negativeAwareModulo()

template<typename IntegerType>

IntegerType juce::negativeAwareModulo ( IntegerType dividend, const IntegerType divisor )

noexcept

Performs a modulo operation, but can cope with the dividend being negative. The divisor must be greater than zero.

nextPowerOfTwo()

int juce::nextPowerOfTwo ( int n )

inlinenoexcept

Returns the smallest power-of-two which is equal to or greater than the given integer.

normaliseSeparators()

String juce::normaliseSeparators ( const String & path )

static

notifyAccessibilityEventInternal()

void juce::notifyAccessibilityEventInternal	(	const AccessibilityHandler &	handler,
		InternalAccessibilityEvent	eventType )

nsArrayToVar()

var juce::nsArrayToVar ( NSArray * array )

inline

nsDictionaryToVar()

var juce::nsDictionaryToVar ( NSDictionary * dictionary )

inline

nsEmptyString()

NSString * juce::nsEmptyString ( )

inlinenoexcept

nsObjectToVar()

var juce::nsObjectToVar ( NSObject * array )

inline

nsRangeToJuce()

Range< int > juce::nsRangeToJuce ( NSRange range )

inline

nsStringLiteral()

NSString * juce::nsStringLiteral ( const char *const s )

inlinenoexcept

nsStringToJuce()

String juce::nsStringToJuce ( NSString * s )

inline

numElementsInArray()

template<typename Type, size_t N>

int juce::numElementsInArray ( Type(&) [N] )

constexprnoexcept

Handy function for getting the number of elements in a simple const C array. E.g.

static int myArray[] = { 1, 2, 3 };
 
int numElements = numElementsInArray (myArray) // returns 3

ObjCMsgSendSuper()

template<typename SuperType, typename ReturnType, typename... Params>

ReturnType juce::ObjCMsgSendSuper ( id self, SEL sel, Params... params )

inline

offerKeyMessageToJUCEWindow()

bool juce::offerKeyMessageToJUCEWindow

(

MSG &

m

)

operator!=() [1/24]

bool juce::operator!= ( const Displays::Display & d1, const Displays::Display & d2 )

noexcept

operator!=() [2/24]

template<class T, class U>

bool juce::operator!=	(	const Optional< T > &	lhs,
		const Optional< U > &	rhs )

operator!=() [3/24]

template<class T, class U>

bool juce::operator!=	(	const Optional< T > &	opt,
		const U &	value )

operator!=() [4/24]

template<class T>

bool juce::operator!= ( const Optional< T > & opt, Nullopt  )

noexcept

operator!=() [5/24]

template<class ObjectType>

bool juce::operator!= ( const ScopedPointer< ObjectType > & pointer, decltype(nullptr)  )

noexcept

operator!=() [6/24]

template<typename ObjectType1, typename ObjectType2>

bool juce::operator!= ( const ScopedPointer< ObjectType1 > & pointer1, const ScopedPointer< ObjectType2 > & pointer2 )

noexcept

operator!=() [7/24]

template<typename ObjectType1, typename ObjectType2>

bool juce::operator!= ( const ScopedPointer< ObjectType1 > & pointer1, ObjectType2 * pointer2 )

noexcept

operator!=() [8/24]

JUCE_API bool JUCE_CALLTYPE juce::operator!= ( const String & string1, const char * string2 )

noexcept

Case-sensitive comparison of two strings.

operator!=() [9/24]

JUCE_API bool JUCE_CALLTYPE juce::operator!= ( const String & string1, CharPointer_UTF16 string2 )

noexcept

Case-sensitive comparison of two strings.

operator!=() [10/24]

JUCE_API bool JUCE_CALLTYPE juce::operator!= ( const String & string1, CharPointer_UTF32 string2 )

noexcept

Case-sensitive comparison of two strings.

operator!=() [11/24]

JUCE_API bool JUCE_CALLTYPE juce::operator!= ( const String & string1, CharPointer_UTF8 string2 )

noexcept

Case-sensitive comparison of two strings.

operator!=() [12/24]

JUCE_API bool JUCE_CALLTYPE juce::operator!= ( const String & string1, const String & string2 )

noexcept

Case-sensitive comparison of two strings.

operator!=() [13/24]

JUCE_API bool JUCE_CALLTYPE juce::operator!= ( const String & string1, const wchar_t * string2 )

noexcept

Case-sensitive comparison of two strings.

operator!=() [14/24]

JUCE_API bool JUCE_CALLTYPE juce::operator!= ( const String & string1, StringRef string2 )

noexcept

Case-sensitive comparison of two strings.

operator!=() [15/24]

template<class T, class U>

bool juce::operator!=	(	const T &	value,
		const Optional< U > &	opt )

operator!=() [16/24]

template<typename Type>

bool juce::operator!= ( const Type * object1, const ReferenceCountedObjectPtr< Type > & object2 )

noexcept

Compares two ReferenceCountedObjectPtrs.

operator!=() [17/24]

JUCE_API bool juce::operator!=	(	const var &	v1,
		const char *	v2 )

operator!=() [18/24]

JUCE_API bool juce::operator!=	(	const var &	v1,
		const String &	v2 )

operator!=() [19/24]

JUCE_API bool juce::operator!=	(	const var &	,
		const var &	)

Compares the values of two var objects, using the var::equals() comparison.

operator!=() [20/24]

template<class ObjectType>

bool juce::operator!= ( decltype(nullptr) , const ScopedPointer< ObjectType > & pointer )

noexcept

operator!=() [21/24]

template<class T>

bool juce::operator!= ( Nullopt , const Optional< T > & opt )

noexcept

operator!=() [22/24]

template<typename ObjectType1, typename ObjectType2>

bool juce::operator!= ( ObjectType1 * pointer1, const ScopedPointer< ObjectType2 > & pointer2 )

noexcept

operator!=() [23/24]

JUCE_API bool JUCE_CALLTYPE juce::operator!= ( RelativeTime t1, RelativeTime t2 )

noexcept

Compares two RelativeTimes.

operator!=() [24/24]

JUCE_API bool juce::operator!= ( Time time1, Time time2 )

noexcept

Compares two Time objects.

operator""_fr()

Grid::Fr juce::operator""_fr ( unsigned long long fr )

constexpr

operator""_px() [1/2]

Grid::Px juce::operator""_px ( long double px )

constexpr

operator""_px() [2/2]

Grid::Px juce::operator""_px ( unsigned long long px )

constexpr

operator*() [1/2]

const DirectoryEntry & juce::operator* ( const DirectoryEntry & e )

inlinenoexcept

A convenience operator so that the expression *it++ works correctly when it is an instance of RangedDirectoryIterator.

operator*() [2/2]

template<typename ValueType>

Point< ValueType > juce::operator* ( ValueType value, Point< ValueType > p )

noexcept

Multiplies the point's coordinates by a scalar value.

operator+() [1/21]

JUCE_API String JUCE_CALLTYPE juce::operator+	(	char	string1,
		const String &	string2 )

Concatenates two strings.

operator+() [2/21]

template<typename Item>

Array< Item > juce::operator+ ( const Array< Item > & a, const Array< Item > & b )

static

operator+() [3/21]

JUCE_API String JUCE_CALLTYPE juce::operator+	(	const char *	string1,
		const String &	string2 )

Concatenates two strings.

operator+() [4/21]

String juce::operator+ ( const char * s1, StringRef s2 )

inline

operator+() [5/21]

String juce::operator+ ( const NewLine & , const char * s2 )

inline

operator+() [6/21]

String juce::operator+ ( const NewLine & , const NewLine &  )

inline

operator+() [7/21]

JUCE_API String JUCE_CALLTYPE juce::operator+	(	const wchar_t *	string1,
		const String &	string2 )

Concatenates two strings.

operator+() [8/21]

JUCE_API Time juce::operator+ ( RelativeTime delta, Time time )

noexcept

Adds a RelativeTime to a Time.

operator+() [9/21]

JUCE_API RelativeTime JUCE_CALLTYPE juce::operator+ ( RelativeTime t1, RelativeTime t2 )

noexcept

Adds two RelativeTimes together.

operator+() [10/21]

JUCE_API String JUCE_CALLTYPE juce::operator+	(	String	string1,
		char	characterToAppend )

Concatenates two strings.

operator+() [11/21]

JUCE_API String JUCE_CALLTYPE juce::operator+	(	String	string1,
		const char *	string2 )

Concatenates two strings.

operator+() [12/21]

String juce::operator+ ( String s1, const NewLine &  )

inline

operator+() [13/21]

JUCE_API String JUCE_CALLTYPE juce::operator+	(	String	string1,
		const std::string &	string2 )

Concatenates two strings.

operator+() [14/21]

JUCE_API String JUCE_CALLTYPE juce::operator+	(	String	string1,
		const String &	string2 )

Concatenates two strings.

operator+() [15/21]

JUCE_API String JUCE_CALLTYPE juce::operator+	(	String	string1,
		const wchar_t *	string2 )

Concatenates two strings.

operator+() [16/21]

String juce::operator+ ( String s1, StringRef s2 )

inline

operator+() [17/21]

JUCE_API String JUCE_CALLTYPE juce::operator+	(	String	string1,
		wchar_t	characterToAppend )

Concatenates two strings.

operator+() [18/21]

String juce::operator+ ( StringRef s1, const char * s2 )

inline

operator+() [19/21]

String juce::operator+ ( StringRef s1, const String & s2 )

inline

operator+() [20/21]

JUCE_API Time juce::operator+ ( Time time, RelativeTime delta )

noexcept

Adds a RelativeTime to a Time.

operator+() [21/21]

JUCE_API String JUCE_CALLTYPE juce::operator+	(	wchar_t	string1,
		const String &	string2 )

Concatenates two strings.

operator+=()

String & juce::operator+= ( String & s1, const NewLine &  )

inline

operator-() [1/3]

JUCE_API RelativeTime JUCE_CALLTYPE juce::operator- ( RelativeTime t1, RelativeTime t2 )

noexcept

Subtracts two RelativeTimes.

operator-() [2/3]

JUCE_API Time juce::operator- ( Time time, RelativeTime delta )

noexcept

Subtracts a RelativeTime from a Time.

operator-() [3/3]

JUCE_API const RelativeTime juce::operator- ( Time time1, Time time2 )

noexcept

Returns the relative time difference between two times.

operator<() [1/12]

auto juce::operator< ( const Font & a, const Font & b )

static

operator<() [2/12]

auto juce::operator< ( const Justification & a, const Justification & b )

static

operator<() [3/12]

template<class T>

bool juce::operator< ( const Optional< T > & , Nullopt  )

noexcept

operator<() [4/12]

template<class T, class U>

bool juce::operator<	(	const Optional< T > &	lhs,
		const Optional< U > &	rhs )

operator<() [5/12]

template<class T, class U>

bool juce::operator<	(	const Optional< T > &	opt,
		const U &	value )

operator<() [6/12]

template<typename T>

auto juce::operator< ( const Rectangle< T > & a, const Rectangle< T > & b )

static

operator<() [7/12]

JUCE_API bool JUCE_CALLTYPE juce::operator< ( const String & string1, StringRef string2 )

noexcept

Case-sensitive comparison of two strings.

operator<() [8/12]

template<class T, class U>

bool juce::operator<	(	const T &	value,
		const Optional< U > &	opt )

operator<() [9/12]

JUCE_API bool juce::operator<	(	const var &	,
		const var &	)

Compares the values of two var objects, using the var::equals() comparison.

operator<() [10/12]

template<class T>

bool juce::operator< ( Nullopt , const Optional< T > & opt )

noexcept

operator<() [11/12]

JUCE_API bool JUCE_CALLTYPE juce::operator< ( RelativeTime t1, RelativeTime t2 )

noexcept

Compares two RelativeTimes.

operator<() [12/12]

JUCE_API bool juce::operator< ( Time time1, Time time2 )

noexcept

Compares two Time objects.

operator<<() [1/34]

OutputStream &JUCE_CALLTYPE juce::operator<<	(	OutputStream &	stream,
		const BigInteger &	value )

Writes a BigInteger to an OutputStream as a UTF8 decimal string.

operator<<() [2/34]

JUCE_API OutputStream &JUCE_CALLTYPE juce::operator<<	(	OutputStream &	stream,
		const char *	text )

Writes a null-terminated text string to a stream.

operator<<() [3/34]

JUCE_API OutputStream &JUCE_CALLTYPE juce::operator<<	(	OutputStream &	stream,
		char	character )

Writes a character to a stream.

operator<<() [4/34]

JUCE_API OutputStream &JUCE_CALLTYPE juce::operator<<	(	OutputStream &	stream,
		double	number )

Writes a number to a stream as 8-bit characters in the default system encoding.

operator<<() [5/34]

JUCE_API OutputStream &JUCE_CALLTYPE juce::operator<<	(	OutputStream &	stream,
		const File &	fileToRead )

Writes the contents of a file to a stream.

operator<<() [6/34]

JUCE_API OutputStream &JUCE_CALLTYPE juce::operator<<	(	OutputStream &	stream,
		int	number )

Writes a number to a stream as 8-bit characters in the default system encoding.

operator<<() [7/34]

JUCE_API OutputStream &JUCE_CALLTYPE juce::operator<<	(	OutputStream &	stream,
		int64	number )

Writes a number to a stream as 8-bit characters in the default system encoding.

operator<<() [8/34]

JUCE_API OutputStream &JUCE_CALLTYPE juce::operator<<	(	OutputStream &	stream,
		const MemoryBlock &	data )

Writes a block of data from a MemoryBlock to a stream.

operator<<() [9/34]

OutputStream &JUCE_CALLTYPE juce::operator<<	(	OutputStream &	stream,
		const MemoryOutputStream &	streamToRead )

Copies all the data that has been written to a MemoryOutputStream into another stream.

operator<<() [10/34]

JUCE_API OutputStream &JUCE_CALLTYPE juce::operator<<	(	OutputStream &	stream,
		const NewLine &	)

Writes a new-line to a stream. You can use the predefined symbol 'newLine' to invoke this, e.g.

myOutputStream << "Hello World" << newLine << newLine;

See also

OutputStream::setNewLineString

operator<<() [11/34]

JUCE_API OutputStream &JUCE_CALLTYPE juce::operator<<	(	OutputStream &	stream,
		const String &	stringToWrite )

Writes a string to an OutputStream as UTF8.

operator<<() [12/34]

OutputStream &JUCE_CALLTYPE juce::operator<<	(	OutputStream &	,
		const Value &	)

Writes a Value to an OutputStream as a UTF8 string.

operator<<() [13/34]

JUCE_API OutputStream &JUCE_CALLTYPE juce::operator<<	(	OutputStream &	stream,
		InputStream &	streamToRead )

Writes the complete contents of an input stream to an output stream.

operator<<() [14/34]

JUCE_API OutputStream &JUCE_CALLTYPE juce::operator<<	(	OutputStream &	stream,
		StringRef	stringToWrite )

Writes a string to an OutputStream as UTF8.

operator<<() [15/34]

template<class traits>

std::basic_ostream< char, traits > &JUCE_CALLTYPE juce::operator<<	(	std::basic_ostream< char, traits > &	stream,
		const String &	stringToWrite )

This operator allows you to write a juce String directly to std output streams. This is handy for writing strings to std::cout, std::cerr, etc.

operator<<() [16/34]

template<class traits>

std::basic_ostream< wchar_t, traits > &JUCE_CALLTYPE juce::operator<<	(	std::basic_ostream< wchar_t, traits > &	stream,
		const String &	stringToWrite )

This operator allows you to write a juce String directly to std output streams. This is handy for writing strings to std::wcout, std::wcerr, etc.

operator<<() [17/34]

String &JUCE_CALLTYPE juce::operator<< ( String & , bool  )

delete

operator<<() [18/34]

JUCE_API String &JUCE_CALLTYPE juce::operator<<	(	String &	string1,
		char	characterToAppend )

Appends a character at the end of a string.

operator<<() [19/34]

JUCE_API String &JUCE_CALLTYPE juce::operator<<	(	String &	string1,
		const char *	string2 )

Appends a string to the end of the first one.

operator<<() [20/34]

JUCE_API String &JUCE_CALLTYPE juce::operator<<	(	String &	string1,
		const std::string &	string2 )

Appends a string to the end of the first one.

operator<<() [21/34]

JUCE_API String &JUCE_CALLTYPE juce::operator<<	(	String &	string1,
		const String &	string2 )

Appends a string to the end of the first one.

operator<<() [22/34]

JUCE_API String &JUCE_CALLTYPE juce::operator<<	(	String &	string1,
		const wchar_t *	string2 )

Appends a string to the end of the first one.

operator<<() [23/34]

JUCE_API String &JUCE_CALLTYPE juce::operator<<	(	String &	string1,
		double	number )

Appends a decimal number to the end of a string.

operator<<() [24/34]

JUCE_API String &JUCE_CALLTYPE juce::operator<<	(	String &	string1,
		float	number )

Appends a decimal number to the end of a string.

operator<<() [25/34]

JUCE_API String &JUCE_CALLTYPE juce::operator<<	(	String &	string1,
		int	number )

Appends a decimal number to the end of a string.

operator<<() [26/34]

JUCE_API String &JUCE_CALLTYPE juce::operator<<	(	String &	string1,
		int64	number )

Appends a decimal number to the end of a string.

operator<<() [27/34]

JUCE_API String &JUCE_CALLTYPE juce::operator<<	(	String &	string1,
		wchar_t	characterToAppend )

Appends a character at the end of a string.

operator<<() [28/34]

JUCE_API String &JUCE_CALLTYPE juce::operator<<	(	String &	string1,
		long	number )

Appends a decimal number to the end of a string.

operator<<() [29/34]

JUCE_API String &JUCE_CALLTYPE juce::operator<<	(	String &	string1,
		short	number )

Appends a decimal number to the end of a string.

operator<<() [30/34]

JUCE_API String &JUCE_CALLTYPE juce::operator<<	(	String &	string1,
		StringRef	string2 )

Appends a string to the end of the first one.

operator<<() [31/34]

JUCE_API String &JUCE_CALLTYPE juce::operator<<	(	String &	string1,
		uint64	number )

Appends a decimal number to the end of a string.

operator<<() [32/34]

JUCE_API String &JUCE_CALLTYPE juce::operator<<	(	String &	string1,
		uint8	number )

Appends a decimal number to the end of a string.

operator<<() [33/34]

JUCE_API String &JUCE_CALLTYPE juce::operator<<	(	String &	string1,
		unsigned long	number )

Appends a decimal number to the end of a string.

operator<<() [34/34]

String & juce::operator<< ( String & string1, const NewLine &  )

inline

Writes a new-line sequence to a string. You can use the predefined object 'newLine' to invoke this, e.g.

myString << "Hello World" << newLine << newLine;

operator<=() [1/9]

template<class T, class U>

bool juce::operator<=	(	const Optional< T > &	lhs,
		const Optional< U > &	rhs )

operator<=() [2/9]

template<class T, class U>

bool juce::operator<=	(	const Optional< T > &	opt,
		const U &	value )

operator<=() [3/9]

template<class T>

bool juce::operator<= ( const Optional< T > & opt, Nullopt  )

noexcept

operator<=() [4/9]

JUCE_API bool JUCE_CALLTYPE juce::operator<= ( const String & string1, StringRef string2 )

noexcept

Case-sensitive comparison of two strings.

operator<=() [5/9]

template<class T, class U>

bool juce::operator<=	(	const T &	value,
		const Optional< U > &	opt )

operator<=() [6/9]

JUCE_API bool juce::operator<=	(	const var &	,
		const var &	)

Compares the values of two var objects, using the var::equals() comparison.

operator<=() [7/9]

template<class T>

bool juce::operator<= ( Nullopt , const Optional< T > &  )

noexcept

operator<=() [8/9]

JUCE_API bool JUCE_CALLTYPE juce::operator<= ( RelativeTime t1, RelativeTime t2 )

noexcept

Compares two RelativeTimes.

operator<=() [9/9]

JUCE_API bool juce::operator<= ( Time time1, Time time2 )

noexcept

Compares two Time objects.

operator==() [1/24]

bool juce::operator== ( const Displays::Display & d1, const Displays::Display & d2 )

noexcept

operator==() [2/24]

template<class T, class U>

bool juce::operator==	(	const Optional< T > &	lhs,
		const Optional< U > &	rhs )

operator==() [3/24]

template<class T, class U>

bool juce::operator==	(	const Optional< T > &	opt,
		const U &	value )

operator==() [4/24]

template<class T>

bool juce::operator== ( const Optional< T > & opt, Nullopt  )

noexcept

operator==() [5/24]

template<class ObjectType>

bool juce::operator== ( const ScopedPointer< ObjectType > & pointer, decltype(nullptr)  )

noexcept

operator==() [6/24]

template<typename ObjectType1, typename ObjectType2>

bool juce::operator== ( const ScopedPointer< ObjectType1 > & pointer1, const ScopedPointer< ObjectType2 > & pointer2 )

noexcept

operator==() [7/24]

template<typename ObjectType1, typename ObjectType2>

bool juce::operator== ( const ScopedPointer< ObjectType1 > & pointer1, ObjectType2 * pointer2 )

noexcept

operator==() [8/24]

JUCE_API bool JUCE_CALLTYPE juce::operator== ( const String & string1, const char * string2 )

noexcept

Case-sensitive comparison of two strings.

operator==() [9/24]

JUCE_API bool JUCE_CALLTYPE juce::operator== ( const String & string1, CharPointer_UTF16 string2 )

noexcept

Case-sensitive comparison of two strings.

operator==() [10/24]

JUCE_API bool JUCE_CALLTYPE juce::operator== ( const String & string1, CharPointer_UTF32 string2 )

noexcept

Case-sensitive comparison of two strings.

operator==() [11/24]

JUCE_API bool JUCE_CALLTYPE juce::operator== ( const String & string1, CharPointer_UTF8 string2 )

noexcept

Case-sensitive comparison of two strings.

operator==() [12/24]

JUCE_API bool JUCE_CALLTYPE juce::operator== ( const String & string1, const String & string2 )

noexcept

Case-sensitive comparison of two strings.

operator==() [13/24]

JUCE_API bool JUCE_CALLTYPE juce::operator== ( const String & string1, const wchar_t * string2 )

noexcept

Case-sensitive comparison of two strings.

operator==() [14/24]

JUCE_API bool JUCE_CALLTYPE juce::operator== ( const String & string1, StringRef string2 )

noexcept

Case-sensitive comparison of two strings.

operator==() [15/24]

template<class T, class U>

bool juce::operator==	(	const T &	value,
		const Optional< U > &	opt )

operator==() [16/24]

template<typename Type>

bool juce::operator== ( const Type * object1, const ReferenceCountedObjectPtr< Type > & object2 )

noexcept

Compares two ReferenceCountedObjectPtrs.

operator==() [17/24]

JUCE_API bool juce::operator==	(	const var &	v1,
		const char *	v2 )

operator==() [18/24]

JUCE_API bool juce::operator==	(	const var &	v1,
		const String &	v2 )

operator==() [19/24]

JUCE_API bool juce::operator==	(	const var &	,
		const var &	)

Compares the values of two var objects, using the var::equals() comparison.

operator==() [20/24]

template<class ObjectType>

bool juce::operator== ( decltype(nullptr) , const ScopedPointer< ObjectType > & pointer )

noexcept

operator==() [21/24]

template<class T>

bool juce::operator== ( Nullopt , const Optional< T > & opt )

noexcept

operator==() [22/24]

template<typename ObjectType1, typename ObjectType2>

bool juce::operator== ( ObjectType1 * pointer1, const ScopedPointer< ObjectType2 > & pointer2 )

noexcept

operator==() [23/24]

JUCE_API bool JUCE_CALLTYPE juce::operator== ( RelativeTime t1, RelativeTime t2 )

noexcept

Compares two RelativeTimes.

operator==() [24/24]

JUCE_API bool juce::operator== ( Time time1, Time time2 )

noexcept

Compares two Time objects.

operator>() [1/9]

template<class T, class U>

bool juce::operator>	(	const Optional< T > &	lhs,
		const Optional< U > &	rhs )

operator>() [2/9]

template<class T, class U>

bool juce::operator>	(	const Optional< T > &	opt,
		const U &	value )

operator>() [3/9]

template<class T>

bool juce::operator> ( const Optional< T > & opt, Nullopt  )

noexcept

operator>() [4/9]

JUCE_API bool JUCE_CALLTYPE juce::operator> ( const String & string1, StringRef string2 )

noexcept

Case-sensitive comparison of two strings.

operator>() [5/9]

template<class T, class U>

bool juce::operator>	(	const T &	value,
		const Optional< U > &	opt )

operator>() [6/9]

JUCE_API bool juce::operator>	(	const var &	,
		const var &	)

Compares the values of two var objects, using the var::equals() comparison.

operator>() [7/9]

template<class T>

bool juce::operator> ( Nullopt , const Optional< T > &  )

noexcept

operator>() [8/9]

JUCE_API bool JUCE_CALLTYPE juce::operator> ( RelativeTime t1, RelativeTime t2 )

noexcept

Compares two RelativeTimes.

operator>() [9/9]

JUCE_API bool juce::operator> ( Time time1, Time time2 )

noexcept

Compares two Time objects.

operator>=() [1/9]

template<class T>

bool juce::operator>= ( const Optional< T > & , Nullopt  )

noexcept

operator>=() [2/9]

template<class T, class U>

bool juce::operator>=	(	const Optional< T > &	lhs,
		const Optional< U > &	rhs )

operator>=() [3/9]

template<class T, class U>

bool juce::operator>=	(	const Optional< T > &	opt,
		const U &	value )

operator>=() [4/9]

JUCE_API bool JUCE_CALLTYPE juce::operator>= ( const String & string1, StringRef string2 )

noexcept

Case-sensitive comparison of two strings.

operator>=() [5/9]

template<class T, class U>

bool juce::operator>=	(	const T &	value,
		const Optional< U > &	opt )

operator>=() [6/9]

JUCE_API bool juce::operator>=	(	const var &	,
		const var &	)

Compares the values of two var objects, using the var::equals() comparison.

operator>=() [7/9]

template<class T>

bool juce::operator>= ( Nullopt , const Optional< T > & opt )

noexcept

operator>=() [8/9]

JUCE_API bool JUCE_CALLTYPE juce::operator>= ( RelativeTime t1, RelativeTime t2 )

noexcept

Compares two RelativeTimes.

operator>=() [9/9]

JUCE_API bool juce::operator>= ( Time time1, Time time2 )

noexcept

Compares two Time objects.

parseFixedSizeIntAndSkip()

int juce::parseFixedSizeIntAndSkip ( String::CharPointerType & t, int numChars, char charToSkip )

staticnoexcept

parseWildcard()

void juce::parseWildcard ( const String & pattern, StringArray & result )

static

parseXML() [1/2]

std::unique_ptr< XmlElement > juce::parseXML

(

const File &

fileToParse

)

Attempts to parse some XML text, returning a new XmlElement if it was valid. If the parse fails, this will return a nullptr - if you need more information about errors or more parsing options, see the XmlDocument class instead.

See also

XmlDocument, parseXMLIfTagMatches

parseXML() [2/2]

std::unique_ptr< XmlElement > juce::parseXML

(

const String &

textToParse

)

Attempts to parse some XML text, returning a new XmlElement if it was valid. If the parse fails, this will return a nullptr - if you need more information about errors or more parsing options, see the XmlDocument class instead.

See also

XmlDocument, parseXMLIfTagMatches

parseXMLIfTagMatches() [1/2]

std::unique_ptr< XmlElement > juce::parseXMLIfTagMatches	(	const File &	fileToParse,
		StringRef	requiredTag )

Does an inexpensive check to see whether the top-level element has the given tag name, and if that's true, does a full parse and returns the result. If the outer tag doesn't match, or the XML has errors, this will return nullptr;

See also

parseXML

parseXMLIfTagMatches() [2/2]

std::unique_ptr< XmlElement > juce::parseXMLIfTagMatches	(	const String &	textToParse,
		StringRef	requiredTag )

Does an inexpensive check to see whether the top-level element has the given tag name, and if that's true, does a full parse and returns the result. If the outer tag doesn't match, or the XML has errors, this will return nullptr;

See also

parseXML

pathToGeometrySink()

void juce::pathToGeometrySink ( const Path & path, ID2D1GeometrySink * sink, const AffineTransform & transform )

static

performPixelOp()

template<class PixelOperation>

void juce::performPixelOp ( const Image::BitmapData & data, const PixelOperation & pixelOp )

static

POINTFromPoint()

POINT juce::POINTFromPoint ( Point< int > p )

staticnoexcept

pointFromPOINT()

Point< int > juce::pointFromPOINT ( POINT p )

staticnoexcept

pointTransformed()

D2D1_POINT_2F juce::pointTransformed ( int x, int y, const AffineTransform & transform )

static

printCommandDescription()

void juce::printCommandDescription ( const ArgumentList & args, const ConsoleApplication::Command & command, int descriptionIndent )

static

processBlockForBuffer()

template<typename FloatType, typename SequenceType>

void juce::processBlockForBuffer ( AudioBuffer< FloatType > & buffer, MidiBuffer & midiMessages, AudioProcessorGraph & graph, std::unique_ptr< SequenceType > & renderSequence, std::atomic< bool > & isPrepared )

static

processDisplay()

void juce::processDisplay ( DisplayNode * currentNode, Array< DisplayNode > & allNodes )

static

Recursive - will calculate and set the logicalArea member of current.

processIOBlock()

template<typename FloatType, typename SequenceType>

void juce::processIOBlock ( AudioProcessorGraph::AudioGraphIOProcessor & io, SequenceType & sequence, AudioBuffer< FloatType > & buffer, MidiBuffer & midiMessages )

static

radiansToDegrees()

template<typename FloatType>

FloatType juce::radiansToDegrees ( FloatType radians )

constexprnoexcept

Converts an angle in radians to degrees.

rawToUniquePtr()

template<typename T>

std::unique_ptr< T > juce::rawToUniquePtr

(

T *

ptr

)

Converts an owning raw pointer into a unique_ptr, deriving the type of the unique_ptr automatically.

This should only be used with pointers to single objects. Do NOT pass a pointer to an array to this function, as the destructor of the unique_ptr will incorrectly call delete instead of delete[] on the pointer.

readChannels()

bool juce::readChannels ( AudioFormatReader & reader, int ** chans, AudioBuffer< float > * buffer, int startSample, int numSamples, int64 readerStartSample, int numTargetChannels, bool convertToFloat )

static

readDeadMansPedalFile()

StringArray juce::readDeadMansPedalFile ( const File & file )

static

readLittleEndianBitsInBuffer()

uint32 juce::readLittleEndianBitsInBuffer ( const void * sourceBuffer, uint32 startBit, uint32 numBits )

noexcept

Reads a number of bits from a buffer at a given bit index. The buffer is treated as a sequence of 8-bit bytes, and the value is encoded in little-endian order, so for example if startBit = 10, and numBits = 11 then the lower 6 bits of the result would be read from bits 2-8 of sourceBuffer[1], and the upper 5 bits of the result from bits 0-5 of sourceBuffer[2].

See also

writeLittleEndianBitsInBuffer

readUnaligned()

template<typename Type>

Type juce::readUnaligned ( const void * srcPtr )

inlinenoexcept

A handy function to read un-aligned memory without a performance penalty or bus-error.

readUnalignedLittleEndianInt()

uint32 juce::readUnalignedLittleEndianInt ( const void * buffer )

inline

readUnalignedLittleEndianShort()

uint16 juce::readUnalignedLittleEndianShort ( const void * buffer )

inline

readWindowsLnkFile()

String juce::readWindowsLnkFile ( File lnkFile, bool wantsAbsolutePath )

static

readWindowsShortcutOrLink()

String juce::readWindowsShortcutOrLink ( const File & shortcut, bool wantsAbsolutePath )

static

rectangleFromRECT()

Rectangle< int > juce::rectangleFromRECT ( RECT r )

staticnoexcept

rectangleToRectF()

template<typename Type>

D2D1_RECT_F juce::rectangleToRectF

(

const Rectangle< Type > &

r

)

RECTFromRectangle()

RECT juce::RECTFromRectangle ( Rectangle< int > r )

staticnoexcept

rectToGeometrySink()

void juce::rectToGeometrySink ( const Rectangle< int > & rect, ID2D1GeometrySink * sink, const AffineTransform & transform )

static

reduceLengthOfFloatString()

String juce::reduceLengthOfFloatString ( const String & input )

static

removeEllipsis()

String juce::removeEllipsis ( const String & path )

static

removePort()

String juce::removePort ( const String & adr )

static

removeScaleFactorListenerFromAllPeers()

void juce::removeScaleFactorListenerFromAllPeers ( ComponentPeer::ScaleFactorListener & listener )

static

replaceColourInFill()

bool juce::replaceColourInFill ( FillType & fill, Colour original, Colour replacement )

static

rescaleMouseWheelDistance()

int juce::rescaleMouseWheelDistance ( float distance, int singleStepSize )

staticnoexcept

resetKeyMappingsToDefaultsCallback()

void juce::resetKeyMappingsToDefaultsCallback ( int result, KeyMappingEditorComponent * owner )

static

resolveFilename()

File juce::resolveFilename ( const String & name )

static

resolveFilenameForOption()

File juce::resolveFilenameForOption ( const ArgumentList & args, StringRef option, const String & filename )

static

resolveXDGFolder()

File juce::resolveXDGFolder ( const char *const type, const char *const fallbackFolder )

static

roleToControlTypeId()

auto juce::roleToControlTypeId ( AccessibilityRole roleType )

static

roundDoubleToInt()

int juce::roundDoubleToInt ( double value )

inlinenoexcept

roundFloatToInt()

int juce::roundFloatToInt ( float value )

inlinenoexcept

roundToInt() [1/2]

template<typename FloatType>

int juce::roundToInt ( const FloatType value )

noexcept

Fast floating-point-to-integer conversion.

This is faster than using the normal c++ cast to convert a float to an int, and it will round the value to the nearest integer, rather than rounding it down like the normal cast does.

Note that this routine gets its speed at the expense of some accuracy, and when rounding values whose floating point component is exactly 0.5, odd numbers and even numbers will be rounded up or down differently.

roundToInt() [2/2]

int juce::roundToInt ( int value )

inlinenoexcept

roundToIntAccurate()

int juce::roundToIntAccurate ( double value )

inlinenoexcept

Fast floating-point-to-integer conversion.

This is a slightly slower and slightly more accurate version of roundToInt(). It works fine for values above zero, but negative numbers are rounded the wrong way.

sendAccessibilityAutomationEvent()

void juce::sendAccessibilityAutomationEvent	(	const AccessibilityHandler &	handler,
		EVENTID	event )

sendAccessibilityPropertyChangedEvent()

void juce::sendAccessibilityPropertyChangedEvent	(	const AccessibilityHandler &	handler,
		PROPERTYID	property,
		VARIANT	newValue )

sendASIODeviceChangeToListeners()

void juce::sendASIODeviceChangeToListeners ( ASIOAudioIODeviceType * type )

static

serialiseDouble()

String juce::serialiseDouble ( double input )

static

setDPIAwareness()

void juce::setDPIAwareness ( )

static

setFileModeFlags()

bool juce::setFileModeFlags ( const String & fullPath, mode_t flags, bool shouldSet )

staticnoexcept

setWindowPos()

void juce::setWindowPos ( HWND hwnd, Rectangle< int > bounds, UINT flags, bool adjustTopLeft = false )

static

setWindowZOrder()

void juce::setWindowZOrder ( HWND hwnd, HWND insertAfter )

static

showDialog() [1/2]

int juce::showDialog ( const MessageBoxOptions & options, ModalComponentManager::Callback * callback, Async async )

static

showDialog() [2/2]

int juce::showDialog ( const MessageBoxOptions & options, ModalComponentManager::Callback * callbackIn, AlertWindowMappings::MapFn mapFn )

static

showFolderForPlugin()

void juce::showFolderForPlugin ( KnownPluginList & list, int index )

static

showMaybeAsync()

int juce::showMaybeAsync ( const MessageBoxOptions & options, ModalComponentManager::Callback * callbackIn, AlertWindowMappings::MapFn mapFn )

static

shutdownJuce_GUI()

JUCE_API void JUCE_CALLTYPE juce::shutdownJuce_GUI

(

)

Clears up any static data being used by JUCE's GUI classes.

If you're embedding JUCE into an application that uses its own event-loop rather than using the START_JUCE_APPLICATION macro, call this function in your shutdown code to clean up any JUCE objects that might be lying around.

See also

initialiseJuce_GUI()

simpleGCD()

BigInteger juce::simpleGCD ( BigInteger * m, BigInteger * n )

static

skipToEndOfXmlComment()

template<typename Iterator>

void juce::skipToEndOfXmlComment ( Iterator & source )

staticnoexcept

skipToEndOfXmlDTD()

template<typename Iterator>

void juce::skipToEndOfXmlDTD ( Iterator & source )

staticnoexcept

snapPointerToAlignment()

template<typename Type, typename IntegerType>

Type * juce::snapPointerToAlignment ( Type * basePointer, IntegerType alignmentBytes )

inlinenoexcept

A handy function to round up a pointer to the nearest multiple of a given number of bytes. alignmentBytes must be a power of two.

sortArray()

template<class ElementType, class ElementComparator>

void juce::sortArray ( ElementComparator & comparator, ElementType *const array, int firstElement, int lastElement, const bool retainOrderOfEquivalentItems )

static

Sorts a range of elements in an array.

The comparator object that is passed-in must define a public method with the following signature:

int compareElements (ElementType first, ElementType second);

..and this method must return:

• a value of < 0 if the first comes before the second
• a value of 0 if the two objects are equivalent
• a value of > 0 if the second comes before the first

To improve performance, the compareElements() method can be declared as static or const.

Parameters

comparator	an object which defines a compareElements() method
array	the array to sort
firstElement	the index of the first element of the range to be sorted
lastElement	the index of the last element in the range that needs sorting (this is inclusive)
retainOrderOfEquivalentItems	if true, the order of items that the comparator deems the same will be maintained - this will be a slower algorithm than if they are allowed to be moved around.

See also

sortArrayRetainingOrder

sortServiceList()

void juce::sortServiceList ( std::vector< NetworkServiceDiscovery::Service > & services )

static

square()

template<typename NumericType>

NumericType juce::square ( NumericType n )

inlineconstexprnoexcept

Returns the square of its argument.

stringCompareLeft()

int juce::stringCompareLeft ( String::CharPointerType s1, String::CharPointerType s2 )

staticnoexcept

stringCompareRight()

int juce::stringCompareRight ( String::CharPointerType s1, String::CharPointerType s2 )

staticnoexcept

substring()

String juce::substring ( const String & text, Range< int > range )

static

swap()

void juce::swap ( ThrowOnMoveOrSwap & , ThrowOnMoveOrSwap &  )

static

swapUserAndEffectiveUser()

bool juce::swapUserAndEffectiveUser ( )

static

tableHeaderMenuCallback()

void juce::tableHeaderMenuCallback ( int result, TableHeaderComponent * tableHeader, int columnIdClicked )

static

testFor() [1/2]

template<typename ToTest, typename CommonClassType, typename SourceClassType>

InterfaceResultWithDeferredAddRef juce::testFor	(	ToTest &	toTest,
		const Steinberg::TUID	targetIID,
		SharedBase< CommonClassType, SourceClassType >	)

testFor() [2/2]

template<typename ToTest, typename ClassType>

InterfaceResultWithDeferredAddRef juce::testFor	(	ToTest &	toTest,
		const Steinberg::TUID	targetIID,
		UniqueBase< ClassType >	)

testForMultiple() [1/2]

template<typename ToTest>

InterfaceResultWithDeferredAddRef juce::testForMultiple	(	ToTest &	,
		const Steinberg::TUID	)

testForMultiple() [2/2]

template<typename ToTest, typename Head, typename... Tail>

InterfaceResultWithDeferredAddRef juce::testForMultiple	(	ToTest &	toTest,
		const Steinberg::TUID	targetIID,
		Head	head,
		Tail...	tail )

threadEntryProc() [1/2]

void * juce::threadEntryProc ( void * userData )

static

threadEntryProc() [2/2]

unsigned int STDMETHODCALLTYPE juce::threadEntryProc ( void * userData )

static

tie()

auto juce::tie ( const AudioDeviceManager::AudioDeviceSetup & s )

static

timeToString()

String juce::timeToString ( double secs )

static

toMap()

auto juce::toMap ( const StringPairArray & array )

static

toString() [1/5]

Steinberg::Vst::TChar * juce::toString ( const juce::String & source )

inlinenoexcept

toString() [2/5]

juce::String juce::toString ( const Steinberg::char16 * string )

inlinenoexcept

toString() [3/5]

juce::String juce::toString ( const Steinberg::char8 * string )

inlinenoexcept

toString() [4/5]

juce::String juce::toString ( const Steinberg::UString128 & string )

inlinenoexcept

toString() [5/5]

juce::String juce::toString ( const Steinberg::UString256 & string )

inlinenoexcept

toString128() [1/2]

void juce::toString128 ( Steinberg::Vst::String128 result, const char * source )

inline

toString128() [2/2]

void juce::toString128 ( Steinberg::Vst::String128 result, const juce::String & source )

inline

transformToMatrix()

D2D1::Matrix3x2F juce::transformToMatrix ( const AffineTransform & transform )

static

translate() [1/4]

JUCE_API String juce::translate

(

CharPointer_UTF8

stringLiteral

)

Uses the LocalisedStrings class to translate the given string literal.

See also

LocalisedStrings

translate() [2/4]

JUCE_API String juce::translate

(

const char *

stringLiteral

)

Uses the LocalisedStrings class to translate the given string literal.

See also

LocalisedStrings

translate() [3/4]

JUCE_API String juce::translate

(

const String &

stringLiteral

)

Uses the LocalisedStrings class to translate the given string literal.

See also

LocalisedStrings

translate() [4/4]

JUCE_API String juce::translate	(	const String &	stringLiteral,
		const String &	resultIfNotFound )

Uses the LocalisedStrings class to translate the given string literal.

See also

LocalisedStrings

translateTimeField()

String juce::translateTimeField ( int n, const char * singular, const char * plural )

static

truncatePositiveToUnsignedInt()

template<typename FloatType>

unsigned int juce::truncatePositiveToUnsignedInt ( FloatType value )

noexcept

Truncates a positive floating-point number to an unsigned int.

This is generally faster than static_cast<unsigned int> (std::floor (x)) but it only works for positive numbers small enough to be represented as an unsigned int.

unalignedPointerCast() [1/2]

template<typename Type, typename std::enable_if< std::is_pointer< Type >::value, int >::type = 0>

Type juce::unalignedPointerCast ( const void * ptr )

inlinenoexcept

Casts a pointer to another type via void*, which suppresses the cast-align warning which sometimes arises when casting pointers to types with different alignment. You should only use this when you know for a fact that the input pointer points to a region that has suitable alignment for Type, e.g. regions returned from malloc/calloc that should be suitable for any non-over-aligned type.

unalignedPointerCast() [2/2]

template<typename Type, typename std::enable_if< std::is_pointer< Type >::value, int >::type = 0>

Type juce::unalignedPointerCast ( void * ptr )

inlinenoexcept

Casts a pointer to another type via void*, which suppresses the cast-align warning which sometimes arises when casting pointers to types with different alignment. You should only use this when you know for a fact that the input pointer points to a region that has suitable alignment for Type, e.g. regions returned from malloc/calloc that should be suitable for any non-over-aligned type.

updateButtonTickColour()

void juce::updateButtonTickColour ( ToggleButton * button, bool usingDefault )

static

updateKeyModifiers()

void juce::updateKeyModifiers ( int status )

staticnoexcept

updateKeyModifiersFromSym()

bool juce::updateKeyModifiersFromSym ( KeySym sym, bool press )

staticnoexcept

updateKeyStates()

void juce::updateKeyStates ( int keycode, bool press )

staticnoexcept

updateOnMessageThread()

void juce::updateOnMessageThread ( AsyncUpdater & updater )

static

updateSetupChannels()

void juce::updateSetupChannels ( AudioDeviceManager::AudioDeviceSetup & setup, int defaultNumIns, int defaultNumOuts )

static

uuidFromString()

GUID juce::uuidFromString ( const char * s )

inlinenoexcept

validateLayouts()

template<typename FloatType, typename Iterator>

bool juce::validateLayouts ( Iterator first, Iterator last, const std::vector< DynamicChannelMapping > & map )

static

varArrayToNSArray()

NSArray * juce::varArrayToNSArray ( const var & varToParse )

inline

varObjectToNSDictionary()

NSDictionary * juce::varObjectToNSDictionary ( const var & varToParse )

inline

viewportWouldScrollOnEvent()

bool juce::viewportWouldScrollOnEvent ( const Viewport * vp, const MouseInputSource & src )

staticnoexcept

with() [1/2]

template<typename Member, typename Item>

PopupMenu::Options juce::with ( PopupMenu::Options options, Member && member, Item && item )

static

with() [2/2]

template<typename Member, typename Item>

URL::InputStreamOptions juce::with ( URL::InputStreamOptions options, Member && member, Item && item )

static

withCheckedComArgs()

template<typename Value, typename Object, typename Callback>

JUCE_COMRESULT juce::withCheckedComArgs ( Value * pRetVal, Object & handle, Callback && callback )

inline

withMember()

template<typename Object, typename OtherObject, typename Member>

Object juce::withMember	(	Object	copy,
		Member OtherObject::*	member,
		Member &&	value )

Copies an object, sets one of the copy's members to the specified value, and then returns the copy.

writeIntToStream()

template<typename IntegerType>

void juce::writeIntToStream ( OutputStream & stream, IntegerType number )

static

writeLittleEndianBitsInBuffer()

void juce::writeLittleEndianBitsInBuffer ( void * targetBuffer, uint32 startBit, uint32 numBits, uint32 value )

noexcept

Writes a number of bits into a memory buffer at a given bit index. The buffer is treated as a sequence of 8-bit bytes, and the value is encoded in little-endian order, so for example if startBit = 10, and numBits = 11 then the lower 6 bits of the value would be written into bits 2-8 of targetBuffer[1], and the upper 5 bits of value into bits 0-5 of targetBuffer[2].

See also

readLittleEndianBitsInBuffer

writeUnaligned()

template<typename Type>

void juce::writeUnaligned ( void * dstPtr, Type value )

inlinenoexcept

A handy function to write un-aligned memory without a performance penalty or bus-error.

zeromem()

void juce::zeromem ( void * memory, size_t numBytes )

inlinenoexcept

Fills a block of memory with zeros.

zerostruct()

template<typename Type>

void juce::zerostruct ( Type & structure )

inlinenoexcept

Overwrites a structure or object with zeros.

zeroUnusedBytes()

void juce::zeroUnusedBytes ( uint8 * address )

staticnoexcept

Variable Documentation

accessibilityEventSetContentChangeTypes

jmethodID juce::accessibilityEventSetContentChangeTypes = nullptr

static

adsrTests

ADSRTests juce::adsrTests

static

aiffFormatName

const char* const juce::aiffFormatName = "AIFF file"

static

arg

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void* juce::arg

base64DecodingTable

const char juce::base64DecodingTable[]

static

Initial value:

                                      =
{
    63, 0, 0, 0, 0, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 0, 0, 0, 0, 0, 0, 0,
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
    0, 0, 0, 0, 0, 0, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52
}

base64EncodingTable

const char juce::base64EncodingTable[] = ".ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+"

static

bubblePaddingX

const float juce::bubblePaddingX = 20.0f

bubblePaddingY

const float juce::bubblePaddingY = 14.0f

callOutBoxDismissCommandId

int juce::callOutBoxDismissCommandId = 0x4f83a04b

staticconstexpr

canUsePointerAPI

bool juce::canUsePointerAPI = false

static

clearOpenGLGlyphCache

void(* juce::clearOpenGLGlyphCache) ()

(

)

= nullptr

client

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port jack_client_t jack_port_id_t juce::client

closeTouchInputHandle

CloseTouchInputHandleFunc juce::closeTouchInputHandle = nullptr

static

colourPropertyPrefix

const char juce::colourPropertyPrefix[] = "jcclr_"

static

compileUnitMismatchSentinel

this_will_fail_to_link_if_some_of_your_compile_units_are_built_in_release_mode juce::compileUnitMismatchSentinel

static

currentASIODev

ASIOAudioIODevice* juce::currentASIODev[maxNumASIODevices] = {}

static

currentModuleHandle

void* juce::currentModuleHandle = nullptr

static

currentThreadHolderLock

char juce::currentThreadHolderLock[sizeof(SpinLock)]

static

deletedAtShutdownLock

SpinLock juce::deletedAtShutdownLock

static

double_Pi

const constexpr double juce::double_Pi = MathConstants<double>::pi

constexpr

A double-precision constant for pi.

doubleClickTimeOutMs

int juce::doubleClickTimeOutMs = 400

static

dragAndDropStateMap

std::unordered_map<LinuxComponentPeer*, X11DragState> juce::dragAndDropStateMap

static

emptyChar

const juce_wchar juce::emptyChar = 0

static

emptyString

StringHolder juce::emptyString

constexpr

enableNonClientDPIScaling

EnableNonClientDPIScalingFunc juce::enableNonClientDPIScaling = nullptr

static

extendedKeyModifier

const int juce::extendedKeyModifier = 0x10000

flags

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long juce::flags

float_Pi

const constexpr float juce::float_Pi = MathConstants<float>::pi

constexpr

A single-precision constant for pi.

func

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void(* juce::func) (const char *))

(

const char *

)

function

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void juce::function

garbageCollectionInterval

const uint32 juce::garbageCollectionInterval = 30000

static

getAwarenessFromDPIAwarenessContext

GetAwarenessFromDpiAwarenessContextFunc juce::getAwarenessFromDPIAwarenessContext = nullptr

static

getDPIForMonitor

GetDPIForMonitorFunc juce::getDPIForMonitor = nullptr

static

getDPIForWindow

GetDPIForWindowFunc juce::getDPIForWindow = nullptr

static

getGestureInfo

GetGestureInfoFunc juce::getGestureInfo = nullptr

static

getPointerPenInfo

GetPointerPenInfoFunc juce::getPointerPenInfo = nullptr

static

getPointerTouchInfo

GetPointerTouchInfoFunc juce::getPointerTouchInfo = nullptr

static

getPointerTypeFunction

GetPointerTypeFunc juce::getPointerTypeFunction = nullptr

static

getProcessDPIAwareness

GetProcessDPIAwarenessFunc juce::getProcessDPIAwareness = nullptr

static

getThreadDPIAwarenessContext

GetThreadDPIAwarenessContextFunc juce::getThreadDPIAwarenessContext = nullptr

static

getTouchInputInfo

GetTouchInputInfoFunc juce::getTouchInputInfo = nullptr

static

getWindowDPIAwarenessContext

GetWindowDPIAwarenessContextFunc juce::getWindowDPIAwarenessContext = nullptr

static

globalCrashHandler

SystemStats::CrashHandlerFunction juce::globalCrashHandler = nullptr

static

hasCheckedForDPIAwareness

bool juce::hasCheckedForDPIAwareness = false

static

hasCheckedForMultiTouch

bool juce::hasCheckedForMultiTouch = false

static

hashMapTest

HashMapTest juce::hashMapTest

static

hexDigits

const char juce::hexDigits[] = "0123456789abcdef"

static

hiResCounterHandler

HiResCounterHandler juce::hiResCounterHandler

static

invalidSocket

const SocketHandle juce::invalidSocket = -1

static

isEventBlockedByModalComps

CheckEventBlockedByModalComps juce::isEventBlockedByModalComps = nullptr

jack_client_close

juce::jack_client_close

jack_deactivate

jack_client_t client juce::jack_deactivate

jack_get_ports

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func juce::jack_get_ports

jack_get_sample_rate

jack_client_t client jack_client_t client juce::jack_get_sample_rate

jack_port_by_id

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port juce::jack_port_by_id

jack_port_connected_to

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port jack_client_t jack_port_id_t port_id juce::jack_port_connected_to

jack_port_flags

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port jack_client_t jack_port_id_t port_id const jack_port_t const char port_name juce::jack_port_flags

jack_port_get_total_latency

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg juce::jack_port_get_total_latency

jack_port_name

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags juce::jack_port_name

juce_argc

int juce::juce_argc = 0

juce_argv

const char *const * juce::juce_argv = nullptr

juce_createUnityPeerFn

createUnityPeerFunctionType juce::juce_createUnityPeerFn = nullptr

juce_explicitFocusOrderId

const Identifier juce::juce_explicitFocusOrderId("_jexfo") ( "_jexfo" )

static

juce_getTypefaceForFont

GetTypefaceForFont juce::juce_getTypefaceForFont = nullptr

juce_libjackHandle

void* juce::juce_libjackHandle = nullptr

static

juce_messageWindowHandle

Window juce::juce_messageWindowHandle = nullptr

JUCE_PACKED

class JUCE_API juce::PixelAlpha juce::JUCE_PACKED

juce_xmltextContentAttributeName

const String juce::juce_xmltextContentAttributeName("text") ( "text" )

static

juceAudioHardwareServiceDeviceProperty_VirtualMainVolume

JUCE_END_IGNORE_WARNINGS_GCC_LIKE constexpr auto juce::juceAudioHardwareServiceDeviceProperty_VirtualMainVolume

constexpr

Initial value:

                                                                =
 
 
 
kAudioHardwareServiceDeviceProperty_VirtualMasterVolume

juceAudioObjectPropertyElementMain

auto juce::juceAudioObjectPropertyElementMain

constexpr

Initial value:

                                          =
 
 
 
kAudioObjectPropertyElementMaster

killMessage

const char* juce::killMessage = "__ipc_k_"

static

lastProcessPriority

int juce::lastProcessPriority = -1

static

lastUniquePeerID

uint32 juce::lastUniquePeerID = 1

static

lockedRandom

LockedRandom juce::lockedRandom

static

longMonthNames

const char* const juce::longMonthNames[] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" }

static

lv2PluginFormatTests

LV2PluginFormatTests juce::lv2PluginFormatTests

static

magicXmlNumber

const uint32 juce::magicXmlNumber = 0x21324356

maxNumASIODevices

int juce::maxNumASIODevices = 16

constexpr

memoryReadDummyVariable

int juce::memoryReadDummyVariable

static

millisecondsToDisplaySplash

int juce::millisecondsToDisplaySplash = 2000

staticconstexpr

minNumberOfStringsForGarbageCollection

const int juce::minNumberOfStringsForGarbageCollection = 300

static

newLine

NewLine juce::newLine

A predefined object representing a new-line, which can be written to a string or stream.

To write a new-line to a stream, you can use the predefined 'newLine' variable like this:

myOutputStream << "Hello World" << newLine << newLine;

nodeInfoSetEditable

jmethodID juce::nodeInfoSetEditable = nullptr

static

nodeInfoSetLiveRegion

jmethodID juce::nodeInfoSetLiveRegion = nullptr

static

nodeInfoSetTextSelection

jmethodID juce::nodeInfoSetTextSelection = nullptr

static

nullopt

Nullopt juce::nullopt { 0 }

constexpr

An object that can be used when constructing and comparing Optional instances. Similar to std::nullopt.

numAlwaysOnTopPeers

int juce::numAlwaysOnTopPeers = 0

static

numScopedInitInstances

int juce::numScopedInitInstances = 0

static

ObjCLifetimeManagedClass< Class >::objCLifetimeManagedClass

template<typename Class>

ObjCLifetimeManagedClass<Class> juce::ObjCLifetimeManagedClass< Class >::objCLifetimeManagedClass

optionalUnitTest

OptionalUnitTest juce::optionalUnitTest

static

pingMessage

const char* juce::pingMessage = "__ipc_p_"

static

port

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port jack_client_t jack_port_id_t port_id const jack_port_t const char port_name const jack_port_t * juce::port

port_id

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port jack_client_t jack_port_id_t juce::port_id

port_name

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port jack_client_t jack_port_id_t port_id const jack_port_t const char* juce::port_name

port_name_pattern

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long juce::port_name_pattern

ptr

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long flags const jack_port_t port jack_client_t jack_port_id_t port_id const jack_port_t const char port_name const jack_port_t port void* juce::ptr

rectangleUnitTest

RectangleUnitTest juce::rectangleUnitTest

static

registerTouchWindow

RegisterTouchWindowFunc juce::registerTouchWindow = nullptr

static

rightEdgeSpace

int juce::rightEdgeSpace = 2

constexpr

screenSaverAllowed

bool juce::screenSaverAllowed = true

static

screenSaverDefeater

std::unique_ptr<ScreenSaverDefeater> juce::screenSaverDefeater

static

setProcessDPIAware

SetProcessDPIAwareFunc juce::setProcessDPIAware = nullptr

static

setProcessDPIAwareness

SetProcessDPIAwarenessFunc juce::setProcessDPIAwareness = nullptr

static

setProcessDPIAwarenessContext

SetProcessDPIAwarenessContextFunc juce::setProcessDPIAwarenessContext = nullptr

static

setThreadDPIAwarenessContext

SetThreadDPIAwarenessContextFunc juce::setThreadDPIAwarenessContext = nullptr

static

settingChangeCallback

SettingChangeCallbackFunc juce::settingChangeCallback = nullptr

shortMonthNames

const char* const juce::shortMonthNames[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }

static

shouldDeactivateTitleBar

bool juce::shouldDeactivateTitleBar = true

static

sleepEvent

SleepEvent juce::sleepEvent

static

splashDisplayTime

uint32 juce::splashDisplayTime = 0

static

splashHasStartedFading

bool juce::splashHasStartedFading = false

static

splashScreenFadeOutTime

int juce::splashScreenFadeOutTime = 2000

static

splashScreenLogoHeight

int juce::splashScreenLogoHeight = 63

static

splashScreenLogoWidth

int juce::splashScreenLogoWidth = 123

static

startMessage

const char* juce::startMessage = "__ipc_st"

static

taskDialogIndirect

TaskDialogIndirectFunc juce::taskDialogIndirect = nullptr

static

type_name_pattern

jack_client_t client jack_client_t client jack_client_t client jack_client_t JackInfoShutdownCallback void arg jack_client_t jack_port_t port void func jack_client_t const char const char unsigned long juce::type_name_pattern

valueTreePropertyWithDefaultTests

ValueTreePropertyWithDefaultTests juce::valueTreePropertyWithDefaultTests

static

vst3PluginFormatTests

VST3PluginFormatTests juce::vst3PluginFormatTests

static

wavFormatName

const char* const juce::wavFormatName = "WAV file"

static

windowHandleXContext

XContext juce::windowHandleXContext

wrapperTypeBeingCreated

ThreadLocalValue<AudioProcessor::WrapperType> juce::wrapperTypeBeingCreated

static