| C__map | |
| Cdxd::map< dx::kernel, vm_t > | WDK: kernel space memory mapping |
| Cdxd::map< dx::user, vm_t > | WDK: user space memory mapping |
| C__number | |
| Ccf::type< double > | |
| Ccf::type< float > | |
| Ccf::type< type_t, typename std::enable_if_t<(std::is_enum_v< type_t >||std::is_integral_v< type_t >) &&sizeof(type_t)==1 > > | |
| Ccf::type< type_t, typename std::enable_if_t<(std::is_enum_v< type_t >||std::is_integral_v< type_t >) &&sizeof(type_t)==2 > > | |
| Ccf::type< type_t, typename std::enable_if_t<(std::is_enum_v< type_t >||std::is_integral_v< type_t >) &&sizeof(type_t)==4 > > | |
| Ccf::type< type_t, typename std::enable_if_t<(std::is_enum_v< type_t >||std::is_integral_v< type_t >) &&sizeof(type_t)==8 > > | |
| C_desc_t | |
| Cdx::stream::device<> | |
| Cdx::stream::device< super_device_t, _desc_t, _stream_t > | |
| C_preference | |
| Cdx::key_value_tree< _preference > | |
| CAsioDriverList | |
| Cdx::asio::client::driver< device_t, devices > | |
| CASIOTime | |
| Cdx::asio::driver< device_t, pin_t, driver_t > | |
| CAudioObjectPropertyAddress | |
| Cdx::coreaudio::property | Coreaudio::property |
| Cdx::coreaudio::property::listen | Coreaudio::property::listen |
| CAudioServerPlugInDriverInterface | |
| Cdx::coreaudio::server::plugin< pin_t, device_t, driver_t > | CoreAudio server plugin |
| Cbus_t | |
| Cdx::stream::open< bus_t > | Generic stream open request |
| Ccf::__string< cf_object_t >::less | |
| Ccf::_preference::property | |
| Ccf::array< cf_array_t, cf_basetype_t > | |
| Ccf::array<::CFArrayRef, ::CFMutableArrayRef > | |
| Ccf::array<::CFMutableArrayRef > | |
| Ccf::dictionary< cf_dictionary_t, cf_basetype_t > | Key value pair store |
| Ccf::dictionary<::CFDictionaryRef, ::CFMutableDictionaryRef > | |
| Ccf::dictionary<::CFMutableDictionaryRef > | |
| Ccf::interface< interface_t > | |
| Ccf::interface<::IOCFPlugInInterface > | |
| Ccf::interface<::IOUSBDeviceInterface650 > | |
| Cdx::usb::platform::device< preference_t > | |
| Cdx::usb::platform::device< dx::preference > | |
| Cdx::usb::device< dx::preference > | |
| Cdx::stream::control< usb::device< dx::preference > > | |
| Cdx::stream::device< dx::stream::control< usb::device< dx::preference > >, desc_t, pipe< device< desc_t, dx::preference, pipe > > > | |
| Cdx::usb::stream::_device< desc_t, dx::preference, pipe< device< desc_t, dx::preference, pipe > > > | |
| Cdx::usb::stream::device< desc_t, preference_t, stream_t > | |
| Cdx::usb::device< preference_t > | |
| Cdx::usb::platform::device< preference_t > | |
| Ccf::interface<::IOUSBInterfaceInterface650 > | |
| Cdx::usb::platform::interface | |
| Cdx::usb::interface | |
| Ccf::reference< cf_object_t > | |
| Csec::__code<::SecCodeRef > | |
| Csec::code<::SecCodeRef > | |
| Csec::__code<::SecStaticCodeRef > | |
| Csec::code<::SecStaticCodeRef > | |
| Ccf::__string< cf_object_t > | RAII CFString class |
| Ccf::array<::CFArrayRef, cf_object_t > | |
| Ccf::dictionary<::CFDictionaryRef, cf_object_t > | |
| Ccf::reference< ::CFMutableStringRef > | |
| Ccf::__string<::CFMutableStringRef > | |
| Ccf::type< char * > | |
| Ccf::type< std::string > | |
| Ccf::reference< ::CFStringRef > | |
| Ccf::__string<::CFStringRef > | |
| Ccf::type< const char * > | |
| Cdx::coremidi::stream< device_t, circular_t > | |
| Ccf::reference< ::CFTypeRef > | |
| Csec::item< item_t > | |
| Ccf::reference< item_t > | |
| Csec::__code< item_t > | |
| Ccf::reference<::CFBundleRef > | |
| Ccf::bundle | |
| Ccf::reference<::CFDataRef > | |
| Ccf::data | |
| Ccf::reference<::CFErrorRef > | |
| Ccf::error | |
| Ccf::reference<::CFPropertyListRef > | |
| Cdx::coreaudio::server::_preference | Persistant CoreAudio storarage base class - do not use directly! use coreaudio::server::preference |
| Ccf::reference<::CFReadStreamRef > | |
| Ccf::stream | |
| Ccf::reference<::CFRunLoopSourceRef > | |
| Ccf::runloop::source | |
| Ccf::runloop::pause | |
| Ccf::reference<::CFTypeRef > | |
| Ccf::type<::CFTypeRef > | Opaque type serves as type::factory |
| Ccf::reference<::CFURLRef > | |
| Ccf::url | |
| Ccf::reference<::CFUUIDRef > | |
| Ccf::uuid | |
| Ccf::reference<::SCPreferencesRef > | |
| Csc::_preference | Persistant system configuration storarage base class - do not use directly! use sc::preference |
| Ccf::reference<::SecCertificateRef > | |
| Csec::certificate | Persistant system configuration storarage base class - do not use directly! use sc::preference |
| Cdx::license | |
| Ccf::reference<::SecTrustRef > | |
| Csec::trust | |
| Ccf::tree< derived_t > | Dx::key_value_tree<derived_t> contract (dxd/interface/dx_key_value_tree.h), implemented once for every CF-backed preference store (cf::_preference, sc::_preference, dx::coreaudio::server::_preference) - inherit from this (CRTP: class _preference: public cf::tree<_preference>) instead of reimplementing it |
| Ccf::tree< _preference > | |
| Ccf::_preference | Persistant storarage base class - do not use directly! use cf::preference |
| Cdx::coreaudio::server::_preference | Persistant CoreAudio storarage base class - do not use directly! use coreaudio::server::preference |
| Csc::_preference | Persistant system configuration storarage base class - do not use directly! use sc::preference |
| Ccf::type< type_t, enable_t > | |
| Ccf::type< bool > | |
| Ccontrol< object< device< desc, preference, dx::stream::stream > > > | |
| Cdx::stream::stream< device< desc, preference, dx::stream::stream > > | |
| Ccontrol< object< device_t > > | |
| Cdx::stream::stream< device_t, circular_t > | |
| Cdx::stream::stream< device_t, dx::circular > | |
| Cdx::coreaudio::stream::stream< device_t, circular_t > | |
| Cdx::proxy::stream::stream< device_t, circular_t > | |
| Cdx::stream::stream< device_t, dx::midi::circular > | |
| Cdx::coremidi::stream< device_t, circular_t > | |
| Cdx::stream::stream< device_t, circular_t, super_stream_t, _event_t > | |
| CCUnknown | |
| Cdx::asio::driver< device_t, pin_t, driver_t > | |
| Cdxd::dmus::stream< circular_t, bus_t, stream_desc_t > | Dmus::stream |
| Cdxd::wavert::miniport< stream_t > | Wavert::miniport |
| Cdxd::wavert::stream< stream_desc_t > | Wavert::stream: cyclic WaveRT buffer with client notifications |
| Cdesc_t | |
| Cdx::stream::device< dx::stream::control< dx::proxy::device< preference_t > >, desc_t, stream_t > | |
| Cdx::proxy::stream::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t > > > | |
| Cdx::proxy::stream::_device< desc_t, preference_t, stream_t > | |
| Cdx::stream::device< dx::stream::control< usb::device< preference_t > >, desc_t, stream_t > | |
| Cdx::usb::stream::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t > > > | |
| Cdx::usb::stream::_device< desc_t, preference_t, stream_t > | |
| Cdx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t > | |
| Cdx::service::client::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t > > > | |
| Cdx::virtuel::stream::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t > > > | |
| Cdx::wasapi::client::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t > > > | |
| Cdx::service::client::_device< desc_t, preference_t, stream_t > | Service client streaming device interface class |
| Cdx::virtuel::stream::_device< desc_t, preference_t, stream_t > | Virtual streaming device interface class |
| Cdx::wasapi::client::_device< desc_t, preference_t, stream_t > | WASAPI client streaming device interface class |
| Cdx::stream::device< dx::stream::control< dx::device<::AudioObjectID, preference_t > >, desc_t, stream_t > | |
| Cdx::coreaudio::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t > > > | |
| Cdx::coreaudio::device< desc_t, preference_t, stream_t > | |
| Cdx::coreaudio::_device< desc_t, preference_t, stream_t > | CoreAudio client device |
| Cdx::stream::device< dx::stream::control< dx::device<::MIDIDeviceRef, preference_t > >, desc_t, stream_t > | |
| Cdx::coremidi::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t > > > | |
| Cdx::coremidi::_device< desc_t, preference_t, stream_t > | CoreMIDI client device |
| Cdx::stream::device< dx::stream::control< dx::device< dx::guid, preference_t > >, desc_t, stream_t > | |
| Cdx::asio::client::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t > > > | |
| Cdx::asio::client::_device< desc_t, preference_t, stream_t > | ASIO client streaming device interface class |
| Cdx::stream::device< dx::stream::control< usb::device< dx::preference > >, desc_t, pipe< device< desc_t, dx::preference, pipe > > > | |
| Cdxd::portcls::device< audio_stream_t, midi_stream_t, desc_t > | Adapter device streaming a lower device stack |
| Cdevice::desc::stream::desc | |
| Cdx::stream::stream< device< desc, preference, dx::stream::stream > > | |
| Cdevice_t | |
| Cdx::gui::device< device_t > | Dx::gui::device Mixes an outline presence into a device_t, mirroring the juce interface's nesting one-for-one: device::stream::pin, device::clock::samplerate, device::iosize and device::clients are nested dx::gui::item subclasses here too, each row showing its own controls inline, exactly like the juce TreeView design - the one deviation forced by wx is that every wxWindow needs its parent at construction time, so (unlike juce, which lazily makes a Component once a TreeViewItem becomes visible) device_t's own outline row cannot be built inside its constructor: the generic driver/map machinery constructs device_t itself, before any wx parent window exists. attach() below is therefore called once by the driver, once a wx parent is available, and builds the outline from that point on exactly as juce's device::update() does |
| Cdx::gui::device< device_t > | Dx::gui::device Mixes an outline presence into a device_t, mirroring the juce interface's nesting one-for-one: device::stream::pin, device::clock::samplerate, device::iosize and device::clients are nested dx::gui::item subclasses here too, each row showing its own controls inline, exactly like the juce TreeView design - the one deviation forced by wx is that every wxWindow needs its parent at construction time, so (unlike juce, which lazily makes a Component once a TreeViewItem becomes visible) device_t's own outline row cannot be built inside its constructor: the generic driver/map machinery constructs device_t itself, before any wx parent window exists. attach() below is therefore called once by the driver, once a wx parent is available, and builds the outline from that point on exactly as juce's device::update() does |
| Cdevice_t::desc::stream::desc | |
| Cdx::stream::stream< device_t, circular_t > | |
| Cdx::stream::stream< device_t, circular_t, super_stream_t, event_t > | |
| Cdx::stream::shared::stream< device_t, circular_t, super_stream_t, event_t > | |
| Cdx::stream::stream< device_t, dx::circular > | |
| Cdx::stream::stream< device_t, dx::midi::circular > | |
| Cdx::stream::stream< device_t, dx::circular, usb::pipe< device_t > > | |
| Cdx::usb::stream::pipe< device_t, circular_t, stream_t > | |
| Cdx::stream::stream< device_t, circular_t, super_stream_t, _event_t > | |
| Cdevice_t::desc::stream::pin::desc | |
| Cdx::stream::pin< device_t, _circular_t > | |
| Cdevice_t::desc_t | |
| Cdx::stream::engine< device_t, pin_t, driver_t > | |
| Cdx::asio::driver< device_t, pin_t, driver_t > | |
| Cdx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t > | Generic streaming engine |
| Cdriver_t | |
| Cdx::stream::engine< device_t, pin_t, driver_t > | |
| Cdx::asio::service::driver< driver_t > | |
| Cdx::gui::cpl< driver_t >::frame::panel::driver | |
| Cdx::gui::cpl< driver_t >::window::component::driver | |
| Cdx::service::driver< driver_t > | |
| Cdx::stream::driver< driver_t > | |
| Cdx::test::service::driver< driver_t > | |
| Cdx::__scalar< type_t, resolution > | |
| Cdx::__scalar< type_t, resolution >::cast | |
| Cdx::abstract::event | |
| Cdx::event< kernel > | Kernel triggerable user space event |
| Cdx::usb::platform::pipe< device_t, usb::interface > | |
| Cdx::usb::platform::pipe< device<>, interface > | |
| Cdx::usb::pipe< device_t > | |
| Cdx::usb::platform::pipe< device_t, interface > | |
| Cdx::usb::pipe< device_t > | |
| Cdx::stream::stream< device_t, dx::circular, usb::pipe< device_t > > | |
| Cdx::service::manager::promoted | |
| Cdx::service::manager::enumerate | |
| Cdx::service::manager::status | |
| Cdx::usb::platform::pipe< device_t, interface_t > | |
| Cdx::event< user > | |
| Cdx::usb::platform::pipe< device_t, usb::interface > | |
| Cdx::usb::platform::pipe< device<>, interface > | |
| Cdx::usb::platform::pipe< device_t, interface > | |
| Cdx::event< kernel > | Kernel triggerable user space event |
| Cdx::usb::platform::pipe< device_t, interface_t > | |
| Cdx::shared::event | MacOS user space shared event |
| Cdx::coreaudio::server::device< pin_t > | CoreAudio server streaming device |
| Cdx::service::device< preference_t >::user_client | User client connection The each user_client holds a shared device reference |
| Cdx::aggregate< types > | |
| Cdx::ansi | |
| Cdx::asio::client::_device< desc_t, preference_t, stream_t >::asio | |
| Cdx::asio::client::callbacks | |
| Cdx::asio::client::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t > > > | |
| Cdx::asio::client::_device< desc, preference, stream< device< desc, preference, stream > > > | |
| Cdx::asio::client::device< desc_t, preference_t, stream_t > | |
| Cdx::asio::client::_device< desc_t, preference_t, stream_t > | ASIO client streaming device interface class |
| Cdx::asio::client::driver< device_t, devices >::property | |
| Cdx::asio::client::target | |
| Cdx::asio::driver< device_t, pin_t, driver_t >::pause | |
| Cdx::asio::driver< device_t, pin_t, driver_t >::property | |
| Cdx::circular | Kernel/user space shared circular buffer |
| Cdx::midi::circular | |
| Cdx::usb::midi< buffer_t > | USB MIDI packetizer |
| Cdx::circular::channel< dst_t, src_t > | Copy/mix channel converters |
| Cdx::circular::channel< dst_t, src_t > | |
| Cdx::circular::fence | RAII acquire/release fence bracketing the tx/rx handshake below: acquire on construction, release on destruction, payload access in between. tx/rx stay plain volatile (not std::atomic<>) because this struct is shared byte-for-byte across the app/kernel boundary; the fences give the missing ordering guarantee on weakly-ordered CPUs (Apple Silicon, Windows ARM64) without changing the struct layout |
| Cdx::coreaudio::__target | |
| Cdx::coreaudio::driver< device_t >::property | |
| Cdx::coreaudio::property::device | |
| Cdx::coreaudio::property::plugin | |
| Cdx::coreaudio::property::pod | |
| Cdx::coreaudio::property::pod::device | |
| Cdx::coreaudio::property::pod::stream | |
| Cdx::coreaudio::property::qualifier | |
| Cdx::coreaudio::property::virtuel | |
| Cdx::coreaudio::property::virtuel::device | |
| Cdx::coreaudio::server::control | |
| Cdx::coreaudio::server::control::property | |
| Cdx::coreaudio::server::control::property::clock | |
| Cdx::coreaudio::server::control::property::spdif | |
| Cdx::coreaudio::server::host | |
| Cdx::coreaudio::server::device< pin_t > | CoreAudio server streaming device |
| Cdx::coreaudio::server::plugin< pin_t, device_t, driver_t > | CoreAudio server plugin |
| Cdx::coreaudio::target | |
| Cdx::coreaudio::target::dx_packed | |
| Cdx::coreaudio::target::dx_packed::dx_packed | |
| Cdx::coreaudio::target::dx_packed::dx_packed::dx_packed | |
| Cdx::coremidi::property | Coremidi::property |
| Cdx::coremidi::property::listen | Coremidi::property::listen |
| Cdx::coremidi::target | |
| Cdx::driver< device_id_t, preference_t >::disconnect | |
| Cdx::event< scope_t > | |
| Cdx::coreaudio::property::listen | Coreaudio::property::listen |
| Cdx::coremidi::property::listen | Coremidi::property::listen |
| Cdx::event< dx::kernel > | |
| Cdx::registry | Flat, non-hierarchical Windows registry access to one real key |
| Cdx::key_value_tree< registry > | |
| Cdx::stream::device< desc, preference, dx::stream::stream > | |
| Cdx::proxy::device< dx::preference > | |
| Cdx::stream::control< dx::proxy::device< dx::preference > > | |
| Cdx::stream::device< dx::stream::control< dx::proxy::device< dx::preference > >, dx::stream::desc<>, stream< device< dx::stream::desc<>, dx::preference, stream > > > | |
| Cdx::proxy::stream::_device< dx::stream::desc<>, dx::preference, stream< device< dx::stream::desc<>, dx::preference, stream > > > | |
| Cdx::proxy::stream::device< desc_t, preference_t, stream_t > | |
| Cdx::usb::platform::device< dx::preference > | |
| Cdx::usb::platform::device< preference_t > | |
| Cdx::proxy::device< preference_t > | OS proxy device interface class |
| Cdx::usb::platform::device< preference_t > | |
| Cdx::event< dx::user > | |
| Cdx::service::app | Service::app - Windows Service Windows services are essentially just a type of container for which startup conditions can be defined. The service interface does not support any additional communication. Communication between client and service are usually be implemented using Windows named pipes |
| Cdx::gui::looknfeel | Dx::gui::looknfeel Approximates the juce interface's dark/light colour scheme on the containers wx lets us recolour (frame/panel/splitter backgrounds, the tree, and - via colour inheritance - future field labels) without fighting native control rendering. Buttons, combo boxes, checkboxes and text fields are deliberately left to render as the platform normally would: recolouring native controls fights macOS's own dark-mode appearance, whereas juce draws every control itself and so can commit to one look on every platform |
| Cdx::iobridge< type_t > | Ioctl bridge for 32/64bit user mode/kernel space big/little endian interface |
| Cdx::iterator< container_t > | Range-for support shared by every dxd type whose elements aren't already kept in an STL container of their own (dx::key_value_tree, cf::data, cf::dictionary, cf::array): a derived_t populates container_t however it needs to - a single existing conversion, or an explicit per-element loop - in its own constructor, then calls seed() once population is complete; operator++()/operator!=() forward to container_t's own iterator from then on. operator*() stays derived_t's own: what it should return (a plain element, const or not) differs per user, from cf::data's read-only bytes to dx::key_value_tree's mutable, further-navigable child node |
| Cdx::iterator< container > | |
| Ccf::data::iterator | |
| Cdx::iterator< std::vector< key_value_tree > > | |
| Cdx::key_value_tree< tree_t >::iterator | |
| Cdx::launch< object_t > | RAII object launcher |
| Cdx::license::types | |
| Cdx::listener< listen_t > | Balanced listener client into servers listeners map used from the client side to manage its subscription into the server listeners map |
| Cdx::log | |
| Cdx::log::from | |
| Cdx::log::module | |
| Cdx::log::module::from | |
| Cdx::log::module::to | |
| Cdx::log::scope | |
| Cdx::log::scope::from | |
| Cdx::log::scope::to | |
| Cdx::log::to | |
| Cdx::object | |
| Cdx::device<::io_service_t, preference_t > | |
| Cdx::usb::platform::device< preference_t > | |
| Cdx::service::device< preference_t > | Device - hosts a per-device pipe::server, keyed by puuid, separate from the driver-level control pipe Each connected client is represented by a user_client instance holding a std::shared_ptr<device>, so the device stays alive for as long as any client stays connected to it. conclude() stops that pipe before calling super::conclude(); since pipe::server::stop() unconditionally joins every instance - connected or not - this releases every user_client's device reference synchronously, within the same call. A caller holding the last other std::shared_ptr<device> (e.g. map::driver::remove()) is therefore guaranteed to reach a zero refcount, and run the device's destructor, before conclude() returns - independent of any further pipe activity. This is what lets a deferred cleanup step tied to the device's own destruction (e.g. the Windows registry preference's schedule_erase, dx_registry.h) complete within the same remove() call instead of depending on a future connection |
| Cdx::proxy::device< preference_t > | OS proxy device interface class |
| Cdx::device< std::string, preference_t > | |
| Cdx::proxy::device< preference_t > | OS proxy device interface class |
| Cdx::device< dx::guid, preference > | |
| Cdx::stream::control< dx::device< dx::guid, preference > > | |
| Cdx::stream::device< dx::stream::control< dx::device< dx::guid, preference > >, desc, stream< device< desc, preference, stream > > > | |
| Cdx::asio::client::_device< desc, preference, stream< device< desc, preference, stream > > > | |
| Cdx::device<::AudioObjectID, cf::preference > | |
| Cdx::stream::control< dx::device<::AudioObjectID, cf::preference > > | |
| Cdx::stream::device< dx::stream::control< dx::device<::AudioObjectID, cf::preference > >, dx::virtuel::stream::desc, dx::stream::stream< device< dx::virtuel::stream::desc, cf::preference, dx::stream::stream > > > | |
| Cdx::coreaudio::_device< dx::virtuel::stream::desc, cf::preference, dx::stream::stream< device< dx::virtuel::stream::desc, cf::preference, dx::stream::stream > > > | |
| Cdx::coreaudio::device< desc_t, preference_t, stream_t > | CoreAudio client device |
| Cdx::stream::device< dx::stream::control< dx::device<::AudioObjectID, cf::preference > >, dx::virtuel::stream::desc, stream< device< dx::virtuel::stream::desc, cf::preference, stream > > > | |
| Cdx::coreaudio::_device< dx::virtuel::stream::desc, cf::preference, stream< device< dx::virtuel::stream::desc, cf::preference, stream > > > | |
| Cdx::coreaudio::device< dx::virtuel::stream::desc, cf::preference, stream > | |
| Cdx::coreaudio::pod::device< desc_t, preference_t, stream_t > | CoreAudio stream client device |
| Cdx::coreaudio::stream::device< desc_t, preference_t, stream_t > | CoreAudio stream client device |
| Cdx::device<::MIDIDeviceRef, cf::preference > | |
| Cdx::stream::control< dx::device<::MIDIDeviceRef, cf::preference > > | |
| Cdx::stream::device< dx::stream::control< dx::device<::MIDIDeviceRef, cf::preference > >, desc, stream< device< desc, cf::preference, stream > > > | |
| Cdx::coremidi::_device< desc, cf::preference, stream< device< desc, cf::preference, stream > > > | |
| Cdx::coremidi::device< desc_t, preference_t, stream_t > | CoreMIDI client device |
| Cdx::device<> | |
| Cdx::device<::io_service_t, dx::preference > | |
| Cdx::service::device< dx::preference > | |
| Cdx::proxy::device< dx::preference > | |
| Cdx::usb::platform::device< dx::preference > | |
| Cdx::usb::platform::device< preference_t > | |
| Cdx::device< std::string, dx::preference > | |
| Cdx::proxy::device< dx::preference > | |
| Cdx::stream::control< dx::device< std::string, dx::preference > > | |
| Cdx::stream::device< dx::stream::control< dx::device< std::string, dx::preference > >, desc, dx::stream::shared::stream< device< desc, dx::preference, dx::stream::shared::stream > > > | |
| Cdx::virtuel::stream::_device< desc, dx::preference, dx::stream::shared::stream< device< desc, dx::preference, dx::stream::shared::stream > > > | |
| Cdx::virtuel::stream::device< desc_t, preference_t, stream_t > | |
| Cdx::device< std::string, preference > | |
| Cdx::stream::control< dx::device< std::string, preference > > | |
| Cdx::stream::device< dx::stream::control< dx::device< std::string, preference > >, desc, stream< device< desc, preference, stream > > > | |
| Cdx::service::client::_device< desc, preference, stream< device< desc, preference, stream > > > | |
| Cdx::service::client::device< desc_t, preference_t, stream_t > | |
| Cdx::stream::device< dx::stream::control< dx::device< std::string, preference > >, desc, dx::stream::stream< device< desc, preference, dx::stream::stream > > > | |
| Cdx::wasapi::client::_device< desc, preference, dx::stream::stream< device< desc, preference, dx::stream::stream > > > | |
| Cdx::wasapi::client::device< desc_t, preference_t, stream_t > | |
| Cdx::driver< device_id_t, decltype(device_t::preference)> | |
| Cdx::driver< decltype(id), preference > | |
| Cdx::driver< decltype(id), cf::preference > | |
| Cdx::driver< decltype(_device_t::id), decltype(_device_t::preference)> | |
| Cdx::map::driver< _device_t > | |
| Cdx::driver< decltype(device<>::id), decltype(device<>::preference)> | |
| Cdx::map::driver< device<> > | |
| Cdx::stream::driver< dx::map::driver< device<> > > | |
| Cdx::virtuel::driver< device<> > | |
| Cdx::proxy::driver< device_t > | |
| Cdx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t > | Generic streaming engine |
| Cdx::proxy::driver< device_t > | |
| Cdx::driver< decltype(id), dx::preference > | |
| Cdx::stream::object< device<> > | |
| Cdx::stream::control< stream::object< device<> > > | |
| Cdx::usb::platform::pipe< device<>, interface > | |
| Cdx::stream::control< dx::stream::object< device<> > > | |
| Cdx::usb::platform::pipe< device<>, interface > | |
| Cdx::device< id_t, preference_t > | Abstract commom base device interface class |
| Cdx::service::device< super_device_t > | |
| Cdx::asio::service::device< super_device_t > | |
| Cdx::driver< device_id_t, preference_t > | Abstract base driver interface class This is the abstract base interface to a driver |
| Cdx::map::driver< device_t > | |
| Cdx::proxy::driver< device_t > | |
| Cdx::stream::driver< dx::map::driver< device_t > > | |
| Cdx::proxy::driver< device_t > | |
| Cdx::virtuel::driver< device_t > | |
| Cdx::stream::driver< map::driver< device_t > > | |
| Cdx::coreaudio::driver< device_t > | |
| Cdx::service::client::driver< device_t > | |
| Cdx::asio::client::driver< device_t, devices > | |
| Cdx::coremidi::driver< device_t > | |
| Cdx::wasapi::client::driver< device_t > | WASAPI client driver interface class |
| Cdx::service::app | Service::app - Windows Service Windows services are essentially just a type of container for which startup conditions can be defined. The service interface does not support any additional communication. Communication between client and service are usually be implemented using Windows named pipes |
| Cdx::stream::object< _device_t > | |
| Cdx::stream::control< object< device_t > > | |
| Cdx::stream::pin< device_t, _circular_t > | |
| Cdx::stream::control< stream::object< device_t > > | |
| Cdx::usb::platform::pipe< device_t, usb::interface > | |
| Cdx::usb::platform::pipe< device_t, interface > | |
| Cdx::usb::platform::pipe< device_t, interface_t > | |
| Cdx::stream::control< dx::stream::object< device_t > > | |
| Cdx::usb::platform::pipe< device_t, usb::interface > | |
| Cdx::usb::platform::pipe< device_t, interface > | |
| Cdx::usb::platform::pipe< device_t, interface_t > | |
| Cdx::open< object_t > | RAII manage balanced object open/(close) |
| Cdx::os_event | Kernel/user space shared event representation |
| Cdx::parser | Cmd line parser |
| Cdx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t > | |
| Cdx::select< parsers_t > | Select from aggregated drivers |
| Cdx::service::parser | |
| Cdx::test::device< super_device_t > | |
| Cdx::test::midi::device< super_device_t > | |
| Cdx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t > | |
| Cdx::parser::dispatch | |
| Cdx::pci | Physical PCI stream descriptor |
| Cdx::pci::dma | Physical DMA stream descriptor |
| Cdx::pipe< rcv_t >::access | |
| Cdx::pipe< rcv_t >::server< instance_t, arg_t > | Server - accepts multiple concurrent pipe client connections Each accepted connection is served by its own pipe::server::instance, running on a dedicated read thread. run() keeps exactly one instance listening for the next client at all times: once ConnectNamedPipe() accepts a connection, that instance's own thread calls server::run() again - reaping already-concluded instances and spawning the next listener - before servicing its own connection. A concluded instance (client disconnected) therefore joins only at the start of the next run(), on a different thread: a std::jthread cannot join itself, so reaping cannot happen from within the concluding instance's own read thread. An otherwise idle server thus keeps its most recently used instance around until either the next connection or stop(), which unconditionally joins every instance - connected or not - synchronously before returning |
| Cdx::pipe< rcv_t >::server< instance_t, arg_t >::access | |
| Cdx::power::ac | |
| Cdx::power::acdc | |
| Cdx::power::dc | |
| Cdx::power::acdc | |
| Cdx::power::scheme | |
| Cdx::power::disable_c3 | |
| Cdx::process::mmcss | Mmcss | thread priority/process priority class |
| Cdx::promoted< _value_t >::chain | |
| Cdx::service::client::chain< uint32_t, dx::service::request< service::stream::data< desc > > > | |
| Cdx::service::client::chain< desc, dx::service::request< service::stream::data< desc > > > | |
| Cdx::service::client::chain< uint32_t, dx::service::request< service::stream::data< desc_t > > > | |
| Cdx::service::client::chain< desc_t, dx::service::request< service::stream::data< desc_t > > > | |
| Cdx::service::client::chain< dx::log, dx::service::request< service::stream::data< typename device_t::desc_t > >, uint32_t > | |
| Cdx::service::client::chain< value_t, request_t, server_value_t > | |
| Cdx::promoted< _value_t >::preference< preference_t, preference_value_t > | |
| Cdx::proxy::device< preference_t >::software | Software Device API instance |
| Cdx::proxy::driver< device_t >::notification | |
| Cdx::proxy::driver< device_t >::notification::device | |
| Cdx::proxy::driver< device_t >::property | |
| Cdx::proxy::driver< device< pin_t > > | |
| Cdx::coreaudio::server::plugin< pin_t, device_t, driver_t > | CoreAudio server plugin |
| Cdx::redirect::cerr | |
| Cdx::redirect::clog | |
| Cdx::redirect::cout | |
| Cdx::redirect::indent | |
| Cdx::trace::indent::receipt | |
| Cdx::redirect::indent::dflt | |
| Cdx::reference< object_t > | RAII manage balanced object open/(close) |
| Cdx::resource< invalid_t > | Windows handle class bill wasn't sure wether an invalid handle is a nullptr or -1. Hence the invalid_t template parameter. (Usually its -1, but i.e. for file mappings its nullptr, etc.) |
| Cdx::pipe< request > | |
| Cdx::service::device< preference_t >::user_client | User client connection The each user_client holds a shared device reference |
| Cdx::template server< user_client, std::weak_ptr< device > > | |
| Cdx::template server< request > | |
| Cdx::pipe< dx::service::request< service::stream::data< desc > > > | |
| Cdx::pipe< dx::service::request< service::stream::data< desc_t > > > | |
| Cdx::pipe< dx::service::request< service::stream::data< typename device_t::desc_t > > > | |
| Cdx::pipe< request_t > | |
| Cdx::event< kernel > | Kernel triggerable user space event |
| Cdx::file | |
| Cdx::proxy::device< dx::preference > | |
| Cdx::proxy::device< preference_t > | OS proxy device interface class |
| Cdx::pipe< rcv_t > | Pipe - Windows named pipes A dx::pipe is a bidirection, multi-client, multi-threaded communication channel between a pipe client and a pipe server. Both pipe sides feature a dedicated read thread to receive data from the opposite side notifiying installable listener std::functions. On the service side, a pipe server is instantiated for each pipe client connection. Until a new client connects, the pipe::server::instance remains waiting in pipe::server::instance::connect within its dedicated pipe read thread. If a client disconnects the pipe::server::instance terminates its read thread and is joined and released by the next pipe::server::run() or pipe::server::stop(). The pipe::server::instance super class can be template-parameterized to allow mimicking user client behaviour. Windows arbitrarily serializes operations on synchronous pipe handles, limiting it's named pipe concurrent synchronous operation capabilities to exactly one synchronous pipe per process (i.e. exactly one per process), effectively forcing both the pipe::server and the pipe client to be implemented using asynchronous OVERLAPPED I/O — introducing a whole host of unnecessary pitfalls and awkward behaviors. However, the MSDN documentation here apparently describes a different piece of software. Though dx::pipes can be used for any communication between user space software its purpose is to allow Windows service communication. A service itself runs with elevated privileges, whereas the clients typically run in the normal user context. Therefore, the pipe servers have defined their default ACLs for non-privileged access |
| Cdx::resource< nullptr > | |
| Cdx::shared::memory< dx::stream::clock::monitor > | |
| Cdx::stream::device< super_device_t, _desc_t, _stream_t >::monitor | |
| Cdx::shared::memory< circular_t > | |
| Cdx::stream::shared::stream< device_t, circular_t > | |
| Cdx::stream::shared::stream< device_t, circular_t, super_stream_t, event_t > | |
| Cdx::shared::memory< dx::circular > | |
| Cdx::stream::shared::stream< device_t, dx::circular > | |
| Cdx::coreaudio::pod::stream< device_t, circular_t > | |
| Cdx::stream::shared::stream< device_t, circular_t, super_stream_t, event_t > | |
| Cdx::process | |
| Cdx::shared::memory< buffer_t > | MacOS user space shared memory |
| Cdx::shared::reference | Cross-process, crash-safe named reference count |
| Cdx::shared::memory< dx::stream::clock::monitor > | |
| Cdx::shared::memory< circular_t > | |
| Cdx::shared::memory< dx::circular > | |
| Cdx::shared::memory< buffer_t > | MacOS user space shared memory |
| Cdx::service::accept | |
| Cdx::service::accept::to | |
| Cdx::service::client::driver< device_t >::property | |
| Cdx::service::client::target | |
| Cdx::service::device< preference_t >::promoted | Service::device::chain handle request to/from device::promoted and pipe |
| Cdx::service::driver< driver_t >::property | |
| Cdx::service::manager | |
| Cdx::service::client::driver< device_t > | |
| Cdx::service::parser | |
| Cdx::service::request< data_t > | |
| Cdx::service::start_type | |
| Cdx::service::start_type::from | |
| Cdx::service::start_type::to | |
| Cdx::service::state | |
| Cdx::service::state::to | |
| Cdx::shared::guard< object_t > | Synchronize write/shared read access/destruction |
| Cdx::shared::guard< listeners< listener_t > > | |
| Cdx::listen< listener_t > | Guarded listerners map used from the server side to manage listeners |
| Cdx::shared::guard< listeners< std::function< void(class dx::pipe::server::instance &, const rcv_t &)> > > | |
| Cdx::listen< std::function< void(class dx::pipe::server::instance &, const rcv_t &)> > | |
| Cdx::shared::guard< listeners< std::function< void(const double &)> > > | |
| Cdx::listen< std::function< void(const double &)> > | |
| Cdx::shared::guard< listeners< std::function< void(const dx::service::request< service::stream::data< desc > > &)> > > | |
| Cdx::listen< std::function< void(const dx::service::request< service::stream::data< desc > > &)> > | |
| Cdx::shared::guard< listeners< std::function< void(const dx::service::request< service::stream::data< desc_t > > &)> > > | |
| Cdx::listen< std::function< void(const dx::service::request< service::stream::data< desc_t > > &)> > | |
| Cdx::shared::guard< listeners< std::function< void(const dx::service::request< service::stream::data< typename device_t::desc_t > > &)> > > | |
| Cdx::listen< std::function< void(const dx::service::request< service::stream::data< typename device_t::desc_t > > &)> > | |
| Cdx::shared::guard< listeners< std::function< void(const rcv_t &)> > > | |
| Cdx::listen< std::function< void(const rcv_t &)> > | |
| Cdx::shared::guard< listeners< std::function< void(const request_t &)> > > | |
| Cdx::listen< std::function< void(const request_t &)> > | |
| Cdx::shared::guard< listeners< std::function< void(const value_t &)> > > | |
| Cdx::listen< std::function< void(const value_t &)> > | |
| Cdx::stream::channel::control | |
| Cdx::stream::channel::open< bus_t, max_channels > | Generic stream open request |
| Cdx::stream::channel::opened< data_t, channels > | Generic streaming channel buffer description |
| Cdx::stream::clock | Select/get stream sample rate/iosize |
| Cdx::stream::clock::monitor | Performance monitor shared memory |
| Cdx::stream::clock_value | |
| Cdx::stream::control< object_t >::pause | |
| Cdx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations > | Device streaming interface descriptor |
| Cdx::stream::device< dx::stream::control< dx::device< dx::guid, preference > >, desc, stream< device< desc, preference, stream > > > | |
| Cdx::stream::device< dx::stream::control< dx::device<::MIDIDeviceRef, cf::preference > >, desc, stream< device< desc, cf::preference, stream > > > | |
| Cdx::stream::device< dx::stream::control< dx::proxy::device< dx::preference > >, dx::stream::desc<>, stream< device< dx::stream::desc<>, dx::preference, stream > > > | |
| Cdx::stream::device< dx::stream::control< dx::device< std::string, preference > >, desc, stream< device< desc, preference, stream > > > | |
| Cdx::stream::device< dx::stream::control< dx::device< std::string, dx::preference > >, desc, dx::stream::shared::stream< device< desc, dx::preference, dx::stream::shared::stream > > > | |
| Cdx::stream::device< dx::stream::control< dx::device< std::string, preference > >, desc, dx::stream::stream< device< desc, preference, dx::stream::stream > > > | |
| Cdx::stream::device< desc, preference, dx::stream::stream > | |
| Cdx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations >::clock | |
| Cdx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations >::clock::defaults | |
| Cdx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations >::clock::defaults::iosize | |
| Cdx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations >::clock::defaults::sync | |
| Cdx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations >::clock::defaults::sync::cycle | |
| Cdx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations >::clock::setting | |
| Cdx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations >::clock::setting::external | |
| Cdx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations >::name_id | |
| Cdx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations >::stream | Dx::desc::stream interface descriptor |
| Cdx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations >::stream::config | Dx::desc::stream::config interface descriptor |
| Cdx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations >::stream::config::clock | |
| Cdx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations >::stream::config::clock::sync | |
| Cdx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations >::stream::config::options | |
| Cdx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations >::stream::config::options::spdif | |
| Cdx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations >::stream::config::transaction | |
| Cdx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations >::stream::pin | |
| Cdx::stream::desc< target, 2, 2 > | |
| Cdx::stream::device< dx::stream::control< dx::device<::AudioObjectID, cf::preference > >, dx::virtuel::stream::desc, dx::stream::stream< device< dx::virtuel::stream::desc, cf::preference, dx::stream::stream > > > | |
| Cdx::stream::device< dx::stream::control< dx::device<::AudioObjectID, cf::preference > >, dx::virtuel::stream::desc, stream< device< dx::virtuel::stream::desc, cf::preference, stream > > > | |
| Cdx::stream::device< super_device_t, _desc_t, _stream_t >::property | |
| Cdx::stream::device< super_device_t, _desc_t, _stream_t >::property::sync | |
| Cdx::stream::device< super_device_t, _desc_t, _stream_t >::property::sync::cycle | |
| Cdx::stream::encoder | |
| Cdx::stream::encoder::index | |
| Cdx::stream::format | |
| Cdx::stream::iosize | |
| Cdx::stream::opened< object_t > | Generic shared streaming buffer description |
| Cdx::stream::shared::stream< device_t, dx::circular, dx::stream::control< dx::stream::object< device_t > >, dx::shared::event > | |
| Cdx::service::client::stream< device_t, circular_t, super_stream_t, event_t > | |
| Cdx::stream::start< object_t > | RAII object start/stop balancer |
| Cdx::stream::stream< device_t, circular_t, dx::stream::control< dx::stream::object< device_t > >, dx::shared::event > | |
| Cdx::stream::shared::stream< device_t, circular_t > | |
| Cdx::stream::stream< device_t, dx::circular, dx::stream::control< dx::stream::object< device_t > >, dx::shared::event > | |
| Cdx::stream::shared::stream< device_t, dx::circular > | |
| Cdx::asio::client::stream< device_t, circular_t, super_stream_t, event_t > | |
| Cdx::stream::shared::stream< device_t, circular_t, super_stream_t, event_t > | |
| Cdx::string | |
| Cdx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::match_helper< matching_t > | |
| Cdx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::match_helper< std::set< std::string > > | |
| Cdx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::parameter | |
| Cdx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::parameter::generator | |
| Cdx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::parameter::mask | |
| Cdx::test::driver< super_device_t, audio_pin_t, int32_t, dx::test::device< super_device_t >, dx::proxy::driver< dx::test::device< super_device_t > >, dx::stream::engine< dx::test::device< super_device_t >, audio_pin_t, dx::proxy::driver< dx::test::device< super_device_t > >, int32_t > > | |
| Cdx::test::usb::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t > | |
| Cdx::test::driver< super_device_t, audio_pin_t, int32_t, dx::test::device< super_device_t >, dx::virtuel::driver< dx::test::device< super_device_t > >, dx::stream::engine< dx::test::device< super_device_t >, audio_pin_t, dx::virtuel::driver< dx::test::device< super_device_t > >, int32_t > > | |
| Cdx::test::virtuel::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t > | |
| Cdx::test::driver< super_device_t, audio_pin_t, int32_t, dx::test::midi::device< super_device_t >, dx::proxy::driver< dx::test::midi::device< super_device_t > >, dx::stream::engine< dx::test::midi::device< super_device_t >, audio_pin_t, dx::proxy::driver< dx::test::midi::device< super_device_t > >, int32_t > > | |
| Cdx::test::midi::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t > | |
| Cdx::test::surprise::asynchronous< driver_t > | Concurrently drives synchronous conclude()/launch() cycles (device tree arrival/removal) against whatever else is using the driver, on its own thread |
| Cdx::test::surprise::synchronous< driver_t > | Single, synchronous mid-operation conclude()/launch() cycle, resuming streaming (if it was active) at its prior sample rate once the device is back |
| Cdx::thread::prio | Thread::prio |
| Cdx::thread::workgroup | |
| Cdx::thread::workgroup::interval | |
| Cdx::thread::workgroup::join | |
| Cdx::trace::receipt | |
| Cdx::trace::indent::receipt | |
| Cdx::tty | |
| Cdx::usb::__::endpoint | |
| Cdx::usb::pipe< device_t > | |
| Cdx::usb::pipe< device_t > | |
| Cdx::usb::__::interface | |
| Cdx::usb::interface | |
| Cdx::usb::__request_type | Standard USB control request definitions |
| Cdx::usb::control | |
| Cdx::usb::request< data_t > | |
| Cdx::usb::request< data_t, typename > | |
| Cdx::usb::request< data_t > | |
| Cdx::usb::audio::descriptor | USB audio class descriptors |
| Cdx::usb::audio::descriptor::endpoint | |
| Cdx::usb::audio::descriptor::endpoint::midi | |
| Cdx::usb::audio::descriptor::endpoint::streaming | |
| Cdx::usb::audio::descriptor::endpoint::subtype | |
| Cdx::usb::audio::descriptor::head | |
| Cdx::usb::audio::descriptor::endpoint::midi::general< 1 > | |
| Cdx::usb::audio::descriptor::endpoint::midi::general< jacks > | |
| Cdx::usb::audio::descriptor::endpoint::streaming::general | |
| Cdx::usb::audio::descriptor::interface::control::head | |
| Cdx::usb::audio::descriptor::interface::control::clock_selector< channels > | |
| Cdx::usb::audio::descriptor::interface::control::v1::clock_selector< 1 > | |
| Cdx::usb::audio::descriptor::interface::control::v1::clock_selector1 | |
| Cdx::usb::audio::descriptor::interface::control::v2::clock_selector< 1 > | |
| Cdx::usb::audio::descriptor::interface::control::v2::clock_selector1 | |
| Cdx::usb::audio::descriptor::interface::control::v1::clock_selector< channels > | |
| Cdx::usb::audio::descriptor::interface::control::v2::clock_selector< channels > | |
| Cdx::usb::audio::descriptor::interface::control::clock_selector< 1 > | |
| Cdx::usb::audio::descriptor::interface::control::effect_unit< 1 > | |
| Cdx::usb::audio::descriptor::interface::control::extension_unit< channels > | |
| Cdx::usb::audio::descriptor::interface::control::v1::extension_unit< 1 > | |
| Cdx::usb::audio::descriptor::interface::control::v1::extension_unit1 | |
| Cdx::usb::audio::descriptor::interface::control::v2::extension_unit< 1 > | |
| Cdx::usb::audio::descriptor::interface::control::v2::extension_unit1 | |
| Cdx::usb::audio::descriptor::interface::control::v1::extension_unit< channels > | |
| Cdx::usb::audio::descriptor::interface::control::v2::extension_unit< channels > | |
| Cdx::usb::audio::descriptor::interface::control::extension_unit< 1 > | |
| Cdx::usb::audio::descriptor::interface::control::feature_unit< 1 > | |
| Cdx::usb::audio::descriptor::interface::control::processing_unit< channels > | |
| Cdx::usb::audio::descriptor::interface::control::v1::processing_unit< 1 > | |
| Cdx::usb::audio::descriptor::interface::control::v1::processing_unit1 | |
| Cdx::usb::audio::descriptor::interface::control::v2::processing_unit< 1 > | |
| Cdx::usb::audio::descriptor::interface::control::v2::processing_unit1 | |
| Cdx::usb::audio::descriptor::interface::control::v1::processing_unit< channels > | |
| Cdx::usb::audio::descriptor::interface::control::v2::processing_unit< channels > | |
| Cdx::usb::audio::descriptor::interface::control::processing_unit< 1 > | |
| Cdx::usb::audio::descriptor::interface::control::selector_unit< channels > | |
| Cdx::usb::audio::descriptor::interface::control::v1::selector_unit< 1 > | |
| Cdx::usb::audio::descriptor::interface::control::v1::selector_unit1 | |
| Cdx::usb::audio::descriptor::interface::control::v2::selector_unit< 1 > | |
| Cdx::usb::audio::descriptor::interface::control::v2::selector_unit1 | |
| Cdx::usb::audio::descriptor::interface::control::v1::selector_unit< channels > | |
| Cdx::usb::audio::descriptor::interface::control::v2::selector_unit< channels > | |
| Cdx::usb::audio::descriptor::interface::control::selector_unit< 1 > | |
| Cdx::usb::audio::descriptor::interface::control::clock_multiplier | |
| Cdx::usb::audio::descriptor::interface::control::clock_selector< pins > | |
| Cdx::usb::audio::descriptor::interface::control::clock_source | |
| Cdx::usb::audio::descriptor::interface::control::effect_unit< channels > | |
| Cdx::usb::audio::descriptor::interface::control::v1::effect_unit< 1 > | |
| Cdx::usb::audio::descriptor::interface::control::v1::effect_unit1 | |
| Cdx::usb::audio::descriptor::interface::control::v2::effect_unit< 1 > | |
| Cdx::usb::audio::descriptor::interface::control::v2::effect_unit1 | |
| Cdx::usb::audio::descriptor::interface::control::v1::effect_unit< channels > | |
| Cdx::usb::audio::descriptor::interface::control::v2::effect_unit< channels > | |
| Cdx::usb::audio::descriptor::interface::control::extension_unit< pins > | |
| Cdx::usb::audio::descriptor::interface::control::feature_unit< channels > | |
| Cdx::usb::audio::descriptor::interface::control::v1::feature_unit< 1 > | |
| Cdx::usb::audio::descriptor::interface::control::v1::feature_unit1 | |
| Cdx::usb::audio::descriptor::interface::control::v2::feature_unit< 1 > | |
| Cdx::usb::audio::descriptor::interface::control::v2::feature_unit1 | |
| Cdx::usb::audio::descriptor::interface::control::v1::feature_unit< channels > | |
| Cdx::usb::audio::descriptor::interface::control::v2::feature_unit< channels > | |
| Cdx::usb::audio::descriptor::interface::control::header | |
| Cdx::usb::audio::descriptor::interface::control::processing_unit< pins > | |
| Cdx::usb::audio::descriptor::interface::control::samplerate_converter | |
| Cdx::usb::audio::descriptor::interface::control::selector_unit< pins > | |
| Cdx::usb::audio::descriptor::interface::control::input_terminal::head | |
| Cdx::usb::audio::descriptor::interface::control::input_terminal::v1 | |
| Cdx::usb::audio::descriptor::interface::control::input_terminal::v2 | |
| Cdx::usb::audio::descriptor::interface::control::mixer_unit< pins >::head | |
| Cdx::usb::audio::descriptor::interface::control::mixer_unit< pins >::v1 | |
| Cdx::usb::audio::descriptor::interface::control::mixer_unit< pins >::v2 | |
| Cdx::usb::audio::descriptor::interface::control::output_terminal::head | |
| Cdx::usb::audio::descriptor::interface::control::output_terminal::v1 | |
| Cdx::usb::audio::descriptor::interface::control::output_terminal::v2 | |
| Cdx::usb::audio::descriptor::interface::head | |
| Cdx::usb::audio::descriptor::interface::midi::head | |
| Cdx::usb::audio::descriptor::interface::midi::element< 1, 1 > | |
| Cdx::usb::audio::descriptor::interface::midi::element< pins, caps > | |
| Cdx::usb::audio::descriptor::interface::midi::header | |
| Cdx::usb::audio::descriptor::interface::midi::jack::head | |
| Cdx::usb::audio::descriptor::interface::midi::jack::out< 1 > | |
| Cdx::usb::audio::descriptor::interface::midi::jack::in | |
| Cdx::usb::audio::descriptor::interface::midi::jack::out< pins > | |
| Cdx::usb::audio::descriptor::interface::streaming::format::head | |
| Cdx::usb::audio::descriptor::interface::streaming::format::ex::type2 | |
| Cdx::usb::audio::descriptor::interface::streaming::format::type1::v1 | |
| Cdx::usb::audio::descriptor::interface::streaming::format::type1::v2 | |
| Cdx::usb::audio::descriptor::interface::streaming::format::ex::type1 | |
| Cdx::usb::audio::descriptor::interface::streaming::format::ex::type3 | |
| Cdx::usb::audio::descriptor::interface::streaming::format::type2::v1 | |
| Cdx::usb::audio::descriptor::interface::streaming::format::type2::v2 | |
| Cdx::usb::audio::descriptor::interface::streaming::format::type4 | |
| Cdx::usb::audio::descriptor::interface::streaming::head | |
| Cdx::usb::audio::descriptor::interface::streaming::encoder | |
| Cdx::usb::audio::descriptor::interface::streaming::general::v1 | |
| Cdx::usb::audio::descriptor::interface::streaming::general::v2 | |
| Cdx::usb::audio::descriptor::interface | USB audio class interface descriptors |
| Cdx::usb::audio::descriptor::interface::control | USB audio class control interface descriptors |
| Cdx::usb::audio::descriptor::interface::control::input_terminal | |
| Cdx::usb::audio::descriptor::interface::control::mixer_unit< pins > | |
| Cdx::usb::audio::descriptor::interface::control::output_terminal | |
| Cdx::usb::audio::descriptor::interface::control::subtype | |
| Cdx::usb::audio::descriptor::interface::control::v1 | |
| Cdx::usb::audio::descriptor::interface::control::v1::mixer_unit< pins > | |
| Cdx::usb::audio::descriptor::interface::control::v1::mixer_unit< 1 > | |
| Cdx::usb::audio::descriptor::interface::control::v1::mixer_unit1 | |
| Cdx::usb::audio::descriptor::interface::control::v2 | |
| Cdx::usb::audio::descriptor::interface::control::v2::mixer_unit< pins > | |
| Cdx::usb::audio::descriptor::interface::control::v2::mixer_unit< 1 > | |
| Cdx::usb::audio::descriptor::interface::control::v2::mixer_unit1 | |
| Cdx::usb::audio::descriptor::interface::midi | |
| Cdx::usb::audio::descriptor::interface::midi::jack | |
| Cdx::usb::audio::descriptor::interface::midi::subtype | |
| Cdx::usb::audio::descriptor::interface::streaming | USB audio class streaming interface descriptors |
| Cdx::usb::audio::descriptor::interface::streaming::format | |
| Cdx::usb::audio::descriptor::interface::streaming::format::ex | |
| Cdx::usb::audio::descriptor::interface::streaming::format::type1 | |
| Cdx::usb::audio::descriptor::interface::streaming::format::type2 | |
| Cdx::usb::audio::descriptor::interface::streaming::format::v1 | |
| Cdx::usb::audio::descriptor::interface::streaming::format::v2 | |
| Cdx::usb::audio::descriptor::interface::streaming::format::v2::ex | |
| Cdx::usb::audio::descriptor::interface::streaming::general | |
| Cdx::usb::audio::descriptor::interface::streaming::subtype | |
| Cdx::usb::audio::descriptor::interface::streaming::v1 | |
| Cdx::usb::audio::descriptor::interface::streaming::v2 | |
| Cdx::usb::audio::descriptor::type | |
| Cdx::usb::audio::isoc | |
| Cdx::usb::audio::isoc::cycle | |
| Cdx::usb::stream::pipe< device_t, circular_t, stream_t > | |
| Cdx::usb::audio::isoc::cycle::tick | |
| Cdx::usb::audio::range< ranges_t > | |
| Cdx::usb::audio::subclass | |
| Cdx::usb::descriptor | |
| Cdx::usb::descriptor::type | |
| Cdx::usb::endpoint | USB specific errors |
| Cdx::usb::endpoint::attributes | |
| Cdx::usb::isoc::frame | |
| Cdx::usb::midi< buffer_t >::msg | USB MIDI endpoint element types: defining the element size for a single USB MIDI pipe request |
| Cdx::usb::platform::pipe< device_t, interface_t >::isoc | |
| Cdx::usb::platform::pipe< device_t, interface_t >::isoc::buffer | |
| Cdx::usb::stream::pipe< device_t, circular_t, stream_t >::cache | |
| Cdx::usb::stream::pipe< device_t, circular_t, stream_t >::cache::encoder | |
| Cdx::usb::stream::pipe< device_t, circular_t, stream_t >::isoc | |
| Cdx::virtuel::driver< device_t >::property | |
| Cdx::virtuel::stream::target | |
| Cdx::void_struct | |
| Cdx::wasapi::client::driver< device_t >::property | |
| Cdx::wasapi::client::target | |
| Cdx::wasapi::com | COM apartment of the constructing thread, balanced only if this instance entered it |
| Cdx::wasapi::reference< object_t > | COM interface reference |
| Cdx::wasapi::task_memory< type_t > | CoTaskMemAlloc'd out parameter |
| Cdx::window< driver_t > | |
| Cdxd::__atomic_pointer< type_t > | Atomic pointer operations |
| Cdxd::__atomic_pointer< type_t * > | |
| Cdxd::atomic< type_t * > | Explicitely specify pointer template argument: |
| Cdxd::__atomic_scalar< size, type_t > | |
| Cdxd::__atomic_scalar< 4, type_t > | 32bit atomic operations |
| Cdxd::__atomic_scalar< 8, type_t > | 64bit atomic operations |
| Cdxd::__atomic_scalar< sizeof(event *), event * > | |
| Cdxd::atomic< event * > | |
| Cdxd::linked::list< event > | |
| Cdxd::doubly::linked::list< event > | |
| Cdxd::__atomic_scalar< sizeof(int), int > | |
| Cdxd::atomic< int > | |
| Cdxd::multichannel::stream< channel_t >::in | Kernel stream mapped client reference counted in channel buffers |
| Cdxd::__atomic_scalar< sizeof(item_t *), item_t * > | |
| Cdxd::atomic< item_t * > | |
| Cdxd::linked::list< item_t > | |
| Cdxd::doubly::linked::list< item_t > | Partially lock free doubly linked list |
| Cdxd::__atomic_scalar< sizeof(link *), link * > | |
| Cdxd::atomic< link * > | |
| Cdxd::linked::list< item_t > | Lock free singly linked list |
| Cdxd::doubly::linked::list< doubly::linked::abstract::event > | |
| Cdxd::broadcast | Broadcast signalization of participating linked event items |
| Cdxd::multichannel::stream< channel_t >::clock | |
| Cdxd::stream | Generic kernel stream |
| Cdxd::multichannel::stream< channel_t > | Generic kernel multichannel stream |
| Cdxd::usb_stream_device::stream | USB stream |
| Cdxd::__atomic_scalar< sizeof(long), long > | |
| Cdxd::atomic< long > | |
| Cdxd::__atomic_scalar< sizeof(type_t), type_t > | |
| Cdxd::atomic< type_t * > | Explicitely specify pointer template argument: |
| Cdxd::atomic< type_t > | Atomic operations |
| Cdxd::abstract::event | Abstract::event: base clase to event<dx::user> and event<dx::kernel> to allow mixed user/kernel broadcast signalization |
| Cdxd::event< dx::kernel > | |
| Cdxd::event< dx::kernel > | |
| Cdxd::event< dx::user > | Kernel representation of shared user space event |
| Cdxd::event< dx::user > | Kernel representation of shared user space event |
| Cdxd::adapter::client | User client: one per control open, mirrors dxd::client |
| Cdxd::adapter::device | Per-FDO adapter device: miniport subdevices are created in start() |
| Cdxd::portcls::device< audio_stream_t, midi_stream_t, desc_t > | Adapter device streaming a lower device stack |
| Cdxd::adjust< endian_t > | |
| Cdxd::adjust< host > | |
| Cdxd::adjust< swap > | |
| Cdxd::array< vm_t > | |
| Cdxd::bus | WDM BUS class |
| Cdxd::bus::desc | Device description for bus class |
| Cdxd::client | User client |
| Cdxd::usb_stream_client | Generic USB user client class |
| Cdxd::decay< type_t > | No array/function decay - not needed here |
| Cdxd::driver_creator | Dummy WDF interface class |
| Cdxd::event< scope_t > | Kernel event |
| Cdxd::process | IOKit process thread |
| Cdxd::clock | Kernel-mode periodic software clock, mirroring dx::clock's tick()/run()/halt() shape |
| Cdxd::dmus::stream< circular_t, bus_t, stream_desc_t > | Dmus::stream |
| Cdxd::usb_stream_device::stream | USB stream |
| Cdxd::process | IOKit process thread |
| Cdxd::wdm::irp< synchrony_t > | IRP class |
| Cdxd::portcls::stream< circular_t, bus_t, stream_desc_t > | Portcls::stream base class |
| Cdxd::dmus::stream< circular_t, bus_t, stream_desc_t > | Dmus::stream |
| Cdxd::event< scope > | |
| Cdxd::doubly::linked::event< dx::user > | |
| Cdxd::stream::umap< stream_t > | |
| Cdxd::stream::umap< usb_stream_device::stream > | |
| Cdxd::stream::umap< stream > | |
| Cdxd::multichannel::stream< channel_t >::umap< stream_t > | Stream user mapping |
| Cdxd::stream::umap< stream_t > | Stream user mapping |
| Cdxd::doubly::linked::event< scope > | Semi lock free doubly linked event item |
| Cdxd::linked::event< scope > | Lock free linked event |
| Cdxd::fourchar_string | |
| Cdxd::fw::address | IOKit: FireWire address space |
| Cdxd::fw::phy | IOKit: FireWire physical address space |
| Cdxd::linked::item< item_t > | Singly linked list item |
| Cdxd::doubly::linked::item< item_t > | Semi lock free doubly linked list item |
| Cdxd::linked::item< event > | |
| Cdxd::doubly::linked::item< event > | |
| Cdxd::doubly::linked::abstract::event | Semi lock free doubly linked event list |
| Cdxd::doubly::linked::event< dx::user > | |
| Cdxd::doubly::linked::event< scope > | Semi lock free doubly linked event item |
| Cdxd::linked::abstract::event | Lock free linked event list item |
| Cdxd::linked::event< scope > | Lock free linked event |
| Cdxd::linked::item< link > | |
| Cdxd::linked::link | |
| Cdxd::lock< lock_t > | |
| Cdxd::map< scope_t, vm_t > | WDK memory mapping |
| Cdxd::map< dx::kernel, channel_t > | |
| Cdxd::multichannel::stream< channel_t >::in | Kernel stream mapped client reference counted in channel buffers |
| Cdxd::map< dx::kernel, dx::circular > | |
| Cdxd::stream | Generic kernel stream |
| Cdxd::map< dx::kernel, dx::stream::clock::monitor > | |
| Cdxd::multichannel::stream< channel_t >::clock::monitor | Clock::monitor buffer to be shared with user client mappings to measure jitter and latencies at various levels (IRQ, DPC, ASIO) |
| Cdxd::map< dx::kernel, unsigned int > | |
| Cdxd::multichannel::stream< channel_t >::clock | |
| Cdxd::map< dx::user, dx::circular > | |
| Cdxd::stream::umap< stream_t > | |
| Cdxd::stream::umap< usb_stream_device::stream > | |
| Cdxd::stream::umap< stream > | |
| Cdxd::stream::umap< stream_t > | Stream user mapping |
| Cdxd::memory< scope_t > | Virtual kernel memory description |
| Cdxd::buffer< dx::user > | |
| Cdxd::multichannel::stream< channel_t >::clock | |
| Cdxd::multichannel::stream< channel_t >::clock::monitor | Clock::monitor buffer to be shared with user client mappings to measure jitter and latencies at various levels (IRQ, DPC, ASIO) |
| Cdxd::multichannel::stream< channel_t >::in | Kernel stream mapped client reference counted in channel buffers |
| Cdxd::multichannel::stream< channel_t >::umap< stream_t >::channel | |
| Cdxd::stream | Generic kernel stream |
| Cdxd::buffer< scope_t, limit_t, alignment_t, contigous_t > | Kernel memory buffer w/o alignment and boundary requirements |
| Cdxd::memory< dx::kernel > | |
| Cdxd::buffer< dx::user > | |
| Cdxd::buffer< scope_t, limit_t, alignment_t, contigous_t > | Kernel memory buffer w/o alignment and boundary requirements |
| Cdxd::multichannel::stream< channel_t >::clock | |
| Cdxd::usb_stream_device::clock | |
| Cdxd::mutex | Mutex |
| Cdxd::event< dx::kernel > | |
| Cdxd::promoted< value_t, server_t > | Kernel-mode promoted value, mirroring dx::promoted's server/commit/notify shape |
| Cdxd::usb_stream_device | Generic USB device |
| Cdxd::open< object_t, service_t > | |
| Cdxd::pci::resources | |
| Cdxd::pci::resources::memory | |
| Cdxd::pci::scatter_gather< limit_t, alignment_t, page_size_t > | |
| Cdxd::port | Miniport creation helper |
| Cdxd::port::reference< object_t > | |
| Cdxd::reference< object_t > | Reference holder for object based reference counter |
| Cdxd::referenced | Reference counting base class |
| Cdxd::stream::umap< stream_t > | |
| Cdxd::stream::umap< usb_stream_device::stream > | |
| Cdxd::stream::umap< stream > | |
| Cdxd::stream | Generic kernel stream |
| Cdxd::stream::umap< stream_t > | Stream user mapping |
| Cdxd::remove_reference< type_t > | |
| Cdxd::remove_reference< type_t & > | |
| Cdxd::remove_reference< type_t && > | |
| Cdxd::scoped< object_t > | |
| Cdxd::scoped<::URB > | |
| Cdxd::spinlock | WDK spinlock |
| Cdxd::broadcast | Broadcast signalization of participating linked event items |
| Cdxd::multichannel::stream< channel_t > | Generic kernel multichannel stream |
| Cdxd::stream::opened< packetizer_t > | Generic streaming interface description |
| Cdxd::stream::opened< circular_t > | |
| Cdxd::portcls::stream< circular_t, bus_t, stream_desc_t > | Portcls::stream base class |
| Cdxd::usb_device::pipe::isoc_frame | |
| Cdxd::usb_stream_device::stream::bulk::request | User defined stop commando |
| Cdxd::usb_stream_device::stream::isoc::cycle | |
| Cdxd::usb_stream_device::stream::isoc::request | |
| Cdxd::wdm::device_interface | Enabled device interface: registered and enabled by initialize(), disabled on destruction |
| Cdxd::wdm::file | File class |
| Cdxd::wdm::registry | |
| Cdxd::adapter | PortCls adapter driver |
| Cdxd::device | |
| Cdxd::fw | WDK: FireWire device |
| Cdxd::fw | WDK: FireWire device |
| Cdxd::pci | |
| Cdxd::ppc | PPC device |
| Cdxd::usb_device | |
| Cdxd::usb_stream_device | Generic USB device |
| Cdxd::usb_device | |
| Cdxd::wdm::workitem | WDM workitem helper |
| Cdxd::wstring< length > | |
| Cengine_t | |
| Cdx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t > | |
| CGUID | |
| Cdx::guid | |
| Cdx::proxy::driver< device_t >::setup | |
| Cdxd::guid | |
| Cdxd::portcls::miniport< typename stream_t::stream_desc > | |
| Cdxd::portcls::wave< typename stream_t::stream_desc > | |
| Cdxd::portcls::miniport< stream_t::stream_desc > | |
| Cdxd::portcls::wave< stream_t::stream_desc > | |
| Cdxd::wavert::miniport< stream_t > | Wavert::miniport |
| Cdxd::dmus::miniport< stream_t > | Dmus::miniport |
| Cdxd::portcls::miniport< stream_desc_t > | Portcls::miniport |
| Cdxd::portcls::wave< stream_desc_t > | Wave filter description shared by the wave port models |
| CHUB_DEVICE_CONFIG_INFO | |
| Cdxd::usb_device | |
| CIASIO | |
| Cdx::asio::driver< device_t, pin_t, driver_t > | |
| CIMiniportWaveRT | |
| Cdxd::wavert::miniport< stream_t > | Wavert::miniport |
| CIMiniportWaveRTStreamNotification | |
| Cdxd::wavert::stream< stream_desc_t > | Wavert::stream: cyclic WaveRT buffer with client notifications |
| CIMMNotificationClient | |
| Cdx::wasapi::client::driver< device_t > | WASAPI client driver interface class |
| CIMXF | |
| Cdxd::dmus::stream< circular_t, bus_t, stream_desc_t > | Dmus::stream |
| Cinstance_t | |
| Cdx::pipe< rcv_t >::server< instance_t, arg_t >::instance | |
| Cio::iterator::service | |
| Cio::power | System power notification receiver to get notifications: inherit and connect to runloop |
| Cio::reference< io_object_t > | |
| Cio::reference<::io_iterator_t > | |
| Cio::iterator | Internally used service iterator providing RAII for io_service references - returned when iterating |
| Cio::reference<::io_registry_entry_t > | |
| Cio::registry | MacOS IORegistry access |
| Cdx::service::device< super_device_t > | |
| Cdx::service::device< dx::preference > | |
| Cdx::usb::platform::device< preference_t > | |
| Cdx::usb::platform::device< dx::preference > | |
| Cdx::serial | Serial interface |
| Cdx::service::device< preference_t > | Device - hosts a per-device pipe::server, keyed by puuid, separate from the driver-level control pipe Each connected client is represented by a user_client instance holding a std::shared_ptr<device>, so the device stays alive for as long as any client stays connected to it. conclude() stops that pipe before calling super::conclude(); since pipe::server::stop() unconditionally joins every instance - connected or not - this releases every user_client's device reference synchronously, within the same call. A caller holding the last other std::shared_ptr<device> (e.g. map::driver::remove()) is therefore guaranteed to reach a zero refcount, and run the device's destructor, before conclude() returns - independent of any further pipe activity. This is what lets a deferred cleanup step tied to the device's own destruction (e.g. the Windows registry preference's schedule_erase, dx_registry.h) complete within the same remove() call instead of depending on a future connection |
| Cdx::usb::platform::device< preference_t > | |
| Cjuce::Button::Listener | |
| Cdx::gui::bar | Dx::gui::bar A row of independently toggling buttons, reporting (id, state) on change |
| Cdx::gui::cpl< driver_t >::window::component::driver | |
| Cjuce::ComboBox | |
| Cdx::gui::box< item_t > | |
| Cdx::gui::box< int > | |
| Cdx::gui::power2< item_t > | |
| Cdx::gui::box< item_t > | Dx::gui::box A read-only dropdown of (label, value) pairs, reporting the selected value |
| Cdx::gui::direction< device_t > | |
| Cjuce::ComboBox::Listener | |
| Cdx::gui::box< item_t > | |
| Cdx::gui::box< int > | |
| Cdx::gui::box< item_t > | Dx::gui::box A read-only dropdown of (label, value) pairs, reporting the selected value |
| Cjuce::Component | |
| Cdx::gui::aggregate< image, label, button > | |
| Cdx::gui::aggregate< label, direction< device >, label, power2< juce::String > > | |
| Cdx::gui::aggregate< label, samplerate > | |
| Cdx::gui::aggregate< label, power2< juce::String > > | |
| Cdx::gui::aggregate< component_t > | |
| Cdx::gui::bar | Dx::gui::bar A row of independently toggling buttons, reporting (id, state) on change |
| Cdx::gui::cpl< driver_t >::window::component | |
| Cjuce::FileBasedDocument | |
| Cdx::gui::cpl< driver_t >::window::component::driver | |
| Cjuce::ImageComponent | |
| Cdx::gui::image | |
| Cjuce::JUCEApplication | |
| Cdx::gui::cpl< driver_t > | Dx::gui::cpl wxWidgets counterpart of the juce dx::gui::cpl application shell: a resizable window holding a tree of the driver's devices (with "+"/"-" buttons to create/destroy pod devices), a File/Debug/Help menu bar mirroring the juce interface's New/Open/Import/Save/Save As/Recent/Exit, Logging and About, and the exception hierarchy dialog above for uncaught exceptions |
| Cjuce::Label | |
| Cdx::gui::box< item_t >::label | Box::label Corrects JUCE awkward positioning and size of the juce::ComboBox editor. This is attached by the cpl::looknfeel class |
| Cdx::gui::label | |
| Cjuce::MenuBarModel | |
| Cdx::gui::cpl< driver_t >::window::component::driver | |
| Cjuce::RecentlyOpenedFilesList | |
| Cdx::gui::cpl< driver_t >::window::component::driver | |
| Cjuce::TextButton | |
| Cdx::gui::button | |
| Cjuce::ToggleButton | |
| Cdx::gui::checkbox | |
| Cjuce::TreeView | |
| Cdx::gui::cpl< driver_t >::window::component::driver | |
| Cjuce::TreeViewItem | |
| Cdx::gui::item< component > | |
| Cdx::gui::item< label > | |
| Cdx::gui::device< device_t >::stream< desc_t >::pin | Dx::gui::device::stream::pin Detail row of a single stream pin: name, direction/channels/index, sample format (audio/MIDI, resolution, scalar/float, byte size, endian, alignment), latency and encoder role - grouped into the same dense rows juce uses |
| Cdx::gui::item< checkbox > | |
| Cdx::gui::device< device_t >::clients | Dx::gui::device::clients Detail row listing the processes currently holding this device open. Closed by default, matching juce, and kept live via device.clients.listen |
| Cdx::gui::item< aggregate< image, label, button > > | |
| Cdx::gui::device< device_t > | Dx::gui::device Mixes an outline presence into a device_t, mirroring the juce interface's nesting one-for-one: device::stream::pin, device::clock::samplerate, device::iosize and device::clients are nested dx::gui::item subclasses here too, each row showing its own controls inline, exactly like the juce TreeView design - the one deviation forced by wx is that every wxWindow needs its parent at construction time, so (unlike juce, which lazily makes a Component once a TreeViewItem becomes visible) device_t's own outline row cannot be built inside its constructor: the generic driver/map machinery constructs device_t itself, before any wx parent window exists. attach() below is therefore called once by the driver, once a wx parent is available, and builds the outline from that point on exactly as juce's device::update() does |
| Cdx::gui::item< aggregate< label, samplerate > > | |
| Cdx::gui::item< aggregate< label, power2< juce::String > > > | |
| Cdx::gui::device< device_t >::iosize< desc_t > | Dx::gui::device::iosize Detail row of the device's streaming I/O block size, bounded by the primary clock's supported range and quantised to its tick interval. Closed by default, matching juce |
| Cdx::gui::item< aggregate< label, direction< device >, label, power2< juce::String > > > | |
| Cdx::gui::device< device_t >::stream< desc_t > | Dx::gui::device::stream Detail row of a stream: bidirectional/in/out, channel count, sync-reference eligibility and pin count; rebuilds its dx::gui::device::stream::pin child rows when the pin count changes |
| Cdx::gui::item< component_t > | Dx::gui::item wx counterpart of the juce interface's dx::gui::item<component_t>: one row of a single, continuously expandable outline. Every device and every one of its stream/pin/clock/... rows is an item, nested directly inside its parent item and indented beneath it, showing its own controls inline via content - mirroring juce's TreeView design, where wx has no equivalent of an arbitrary Component hosted per tree row (wxTreeCtrl cannot host child controls), so the outline is built here from plain wxPanel rows in nested box sizers instead |
| Cdx::gui::device< device_t >::clients | Dx::gui::device::clients Detail row listing the processes currently holding this device open. Closed by default, matching juce, and kept live via device.clients.listen |
| Cdx::gui::device< device_t >::clock< desc_t > | Dx::gui::device::clock Detail row of a clock domain: current samplerate, nested (closed by default, matching juce) beneath the set of rates it is allowed to run at |
| Cdx::gui::device< device_t >::clock< desc_t > | Dx::gui::device::clock Detail row of a clock domain: current samplerate, nested (closed by default, matching juce) beneath the set of rates it is allowed to run at |
| Cdx::gui::device< device_t >::iosize< desc_t > | Dx::gui::device::iosize Detail row of the device's streaming I/O block size, bounded by the primary clock's supported range and quantised to its tick interval. Closed by default, matching juce |
| Cdx::gui::device< device_t >::stream< desc_t > | Dx::gui::device::stream Detail row of a stream: bidirectional/in/out, channel count, sync-reference eligibility and pin count; rebuilds its dx::gui::device::stream::pin child rows when the pin count changes |
| Cdx::gui::device< device_t >::stream< desc_t >::pin | Dx::gui::device::stream::pin Detail row of a single stream pin: name, direction/channels/index, sample format (audio/MIDI, resolution, scalar/float, byte size, endian, alignment), latency and encoder role - grouped into the same dense rows juce uses |
| CKSDATARANGE_AUDIO | |
| Cdxd::range::audio | KSDATARANGE_AUDIO constructor |
| CMIDIDriverInterface | |
| Cdx::coremidi::server::plugin< stream_pin_t, device_t, driver_t > | CoreMIDI plugin |
| Cobject_t | |
| Cdx::stream::control< object_t > | |
| Cdx::stream::device< dx::stream::control< dx::proxy::device< preference_t > >, desc_t, stream_t > | |
| Cdx::stream::device< dx::stream::control< usb::device< preference_t > >, desc_t, stream_t > | |
| Cdx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t > | |
| Cdx::stream::device< dx::stream::control< dx::device<::AudioObjectID, preference_t > >, desc_t, stream_t > | |
| Cdx::stream::device< dx::stream::control< dx::device<::MIDIDeviceRef, preference_t > >, desc_t, stream_t > | |
| Cdx::stream::device< dx::stream::control< dx::device< dx::guid, preference_t > >, desc_t, stream_t > | |
| COVERLAPPED | |
| Cdx::overlapped | |
| Cpin_t::device_t | |
| Cdx::coreaudio::server::device< pin_t > | CoreAudio server streaming device |
| CPROCESS_INFORMATION | |
| Cdx::process | |
| Cproxy::driver< device< stream_pin_t > > | |
| Cdx::coremidi::server::plugin< stream_pin_t, device_t, driver_t > | CoreMIDI plugin |
| Cpublic::CUnknown | |
| Cdxd::dmus::miniport< stream_t > | Dmus::miniport |
| Cpublic::IMiniportDMus | |
| Cdxd::dmus::miniport< stream_t > | Dmus::miniport |
| Cpublic::KEVENT | |
| Cdxd::event< dx::kernel > | |
| Cpublic::PCPIN_DESCRIPTOR | |
| Cdxd::portcls::pin | |
| Crequest_t | |
| Cdx::service::client::sync< request_t > | |
| Csec::code< item_t > | |
| CSERVICE_NOTIFYA | |
| Cdx::service::manager::promoted | |
| CSERVICE_STATUS | |
| Cdx::service::app | Service::app - Windows Service Windows services are essentially just a type of container for which startup conditions can be defined. The service interface does not support any additional communication. Communication between client and service are usually be implemented using Windows named pipes |
| CSTARTUPINFOA | |
| Cdx::process | |
| Cstd::basic_string< Char > | STL class |
| Cstd::string | STL class |
| Cdx::coreaudio::_device< desc_t, preference_t, stream_t >::icon | |
| Cdx::gui::file | Given vendor/product-relative path, in the platform's standard app data location |
| Cdx::redirect::eventlog< type_t > | |
| Cdx::redirect::log | Redirect stdout to unified logging |
| Cdx::redirect::syslog | Redirect stdout to syslog |
| Cdx::usb::platform::interface | |
| Cio::registry | MacOS IORegistry access |
| Cstd::bool_constant | |
| Cdx::key_value_tree_enabled< tree_t, value_t, std::void_t< decltype(tree_t::template enabled< value_t >())> > | |
| Cdx::is_string_container< type_t, false >::probe< t, std::void_t< typename t::value_type, decltype(t(std::declval< std::set< std::string >::iterator >(), std::declval< std::set< std::string >::iterator >()))> > | |
| Cdx::key_value_tree_enabled< tree_t, value_t, typename > | |
| Cdx::key_value_tree_enabled< tree_t, value_t, std::void_t< decltype(tree_t::template enabled< value_t >())> > | |
| Cstd::condition_variable | |
| Cdx::event< user > | |
| Cstd::deque< T > | STL class |
| Cdx::coreaudio::property::listen | Coreaudio::property::listen |
| Cdx::coremidi::property::listen | Coremidi::property::listen |
| Cstd::enable_shared_from_this | |
| Cdx::device<::io_service_t, preference_t > | |
| Cdx::device< std::string, preference_t > | |
| Cdx::device< dx::guid, preference > | |
| Cdx::device<::AudioObjectID, cf::preference > | |
| Cdx::device<::MIDIDeviceRef, cf::preference > | |
| Cdx::device<> | |
| Cdx::device<::io_service_t, dx::preference > | |
| Cdx::device< std::string, dx::preference > | |
| Cdx::device< std::string, preference > | |
| Cdx::key_value_tree< _preference > | |
| Cdx::key_value_tree< registry > | |
| Cdx::device< id_t, preference_t > | Abstract commom base device interface class |
| Cdx::key_value_tree< tree_t > | Hierarchical key/value navigation over a flat persistent store |
| Cdx::pipe< rcv_t >::server< instance_t, arg_t >::instance | |
| Cstd::exception | STL class |
| Cstd::runtime_error | STL class |
| Cdx::exception | |
| Cstd::false_type | |
| Cdx::is_dx_iterator< type_t, std::void_t< typename type_t::dx_iterator_tag > > | |
| Cdx::is_initializer_list< std::initializer_list< type_t > > | |
| Cdx::is_smart_pointer< std::shared_ptr< type_t > > | |
| Cdx::is_smart_pointer< std::unique_ptr< type_t, deleter_t > > | |
| Cdx::is_smart_pointer< std::weak_ptr< type_t > > | |
| Cdx::is_string_container< type_t, false > | |
| Cdx::is_string_container< type_t, false >::probe< t, std::void_t< typename t::value_type, decltype(t(std::declval< std::set< std::string >::iterator >(), std::declval< std::set< std::string >::iterator >()))> > | |
| Cdx::promoting< preference_t, std::void_t< decltype(preference_t::listen)> > | |
| Cdx::test::device< super_device_t >::has_license< type_t, decltype((void) type_t::license, void())> | |
| Cdx::is_dx_iterator< type_t, typename > | |
| Cdx::is_initializer_list< type_t > | |
| Cdx::is_smart_pointer< type_t > | |
| Cdx::is_string_container< type_t, bool > | |
| Cdx::is_string_container< type_t, false >::probe< t, typename > | |
| Cdx::promoting< preference_t, typename > | Promoted::preference with default and optional alignment function |
| Cdx::test::device< super_device_t >::has_license< type_t, typename > | |
| Cstd::ios_base | STL class |
| Cstd::basic_ios< Char > | STL class |
| Cstd::basic_ostream< Char > | STL class |
| Cstd::basic_ofstream< Char > | STL class |
| Cstd::ofstream | STL class |
| Cdx::redirect::file | Redirect stdout to file |
| Cstd::ostream | STL class |
| Cdx::redirect::eventlog< type_t > | |
| Cdx::redirect::syslog | Redirect stdout to syslog |
| Cstd::jthread | STL class |
| Cdx::pipe< request > | |
| Cdx::template server< user_client, std::weak_ptr< device > > | |
| Cdx::template server< request > | |
| Cdx::pipe< dx::service::request< service::stream::data< desc > > > | |
| Cdx::pipe< dx::service::request< service::stream::data< desc_t > > > | |
| Cdx::pipe< dx::service::request< service::stream::data< typename device_t::desc_t > > > | |
| Cdx::pipe< request_t > | |
| Cdx::pipe< rcv_t > | Pipe - Windows named pipes A dx::pipe is a bidirection, multi-client, multi-threaded communication channel between a pipe client and a pipe server. Both pipe sides feature a dedicated read thread to receive data from the opposite side notifiying installable listener std::functions. On the service side, a pipe server is instantiated for each pipe client connection. Until a new client connects, the pipe::server::instance remains waiting in pipe::server::instance::connect within its dedicated pipe read thread. If a client disconnects the pipe::server::instance terminates its read thread and is joined and released by the next pipe::server::run() or pipe::server::stop(). The pipe::server::instance super class can be template-parameterized to allow mimicking user client behaviour. Windows arbitrarily serializes operations on synchronous pipe handles, limiting it's named pipe concurrent synchronous operation capabilities to exactly one synchronous pipe per process (i.e. exactly one per process), effectively forcing both the pipe::server and the pipe client to be implemented using asynchronous OVERLAPPED I/O — introducing a whole host of unnecessary pitfalls and awkward behaviors. However, the MSDN documentation here apparently describes a different piece of software. Though dx::pipes can be used for any communication between user space software its purpose is to allow Windows service communication. A service itself runs with elevated privileges, whereas the clients typically run in the normal user context. Therefore, the pipe servers have defined their default ACLs for non-privileged access |
| Cstd::map< K, T > | STL class |
| Cdx::listeners< std::function< void(const value_t &)> > | |
| Cdx::listeners< std::function< void(const double &)> > | |
| Cdx::listeners< std::function< void(const rcv_t &)> > | |
| Cdx::listeners< std::function< void(class dx::pipe::server::instance &, const rcv_t &)> > | |
| Cdx::listeners< std::function< void(const request_t &)> > | |
| Cdx::map::driver< device_t > | |
| Cdx::map::driver< device<> > | |
| Cdx::device< id_t, preference_t >::client_map | |
| Cdx::listeners< listener_t > | Internal helper to map single listener into listerners map |
| Cdx::map::driver< _device_t > | |
| Cstd::mutex | STL class |
| Cdx::promoted< value_t > | |
| Cdx::coreaudio::promoted::property< value_t, coreaudio_value_t, settable > | Coreaudio::promoted::property |
| Cdx::coremidi::promoted::property< value_t, coremidi_value_t, settable > | Coremidi::promoted::property |
| Cdx::proxy::stream::_device< desc_t, preference_t, stream_t >::promoted< value_t, proxy_value_t, _settable > | Dx::proxy::stream::device::promoted with device::preference |
| Cdx::promoted<::DWORD > | |
| Cdx::service::manager::promoted | |
| Cdx::promoted< os_result > | |
| Cdx::pipe< rcv_t >::status | |
| Cdx::promoted< dx::log > | |
| Cdx::promoted< uint32_t > | |
| Cdx::coreaudio::promoted::property< uint32_t > | |
| Cdx::coreaudio::_device< desc_t, preference_t, stream_t >::clocksource | |
| Cdx::proxy::stream::_device< desc_t, preference_t, stream_t >::promoted< uint32_t > | |
| Cdx::promoted< structdesc_t::stream * > | |
| Cdx::promoted< std::string > | |
| Cdx::proxy::stream::_device< desc_t, preference_t, stream_t >::promoted< std::string > | |
| Cdx::promoted< desc > | |
| Cdx::promoted< typename super::client_map > | |
| Cdx::coreaudio::promoted::property< typename super::client_map, typename super::client_map::value_t, false > | |
| Cdx::proxy::stream::_device< desc_t, preference_t, stream_t >::promoted< typename super::client_map, typename super::client_map::value_t > | |
| Cdx::promoted< ::Float64 > | |
| Cdx::coreaudio::promoted::property<::Float64 > | |
| Cdx::promoted< dx::coreaudio::_device::icon > | |
| Cdx::coreaudio::promoted::property< dx::coreaudio::_device::icon, ::CFURLRef, false > | |
| Cdx::promoted< dx::stream::desc<> > | |
| Cdx::proxy::stream::_device< desc_t, preference_t, stream_t >::promoted< dx::stream::desc<>, typename dx::stream::desc<>::value_t > | |
| Cdx::promoted< desc_t > | |
| Cdx::proxy::stream::_device< desc_t, preference_t, stream_t >::promoted< desc_t, typename desc_t::value_t > | |
| Cdx::promoted< ::AudioObjectID > | |
| Cdx::coreaudio::promoted::property<::AudioObjectID > | |
| Cdx::promoted< dx::virtuel::stream::desc > | |
| Cdx::coreaudio::promoted::property< dx::virtuel::stream::desc, ::CFDictionaryRef > | |
| Cdx::promoted< bool > | |
| Cdx::event< user > | |
| Cdx::promoted< _value_t > | Promoted value |
| Cstd::pair< T1, T2 > | STL class |
| Cdx::gui::component_size_pair< component_t > | |
| Cstd::recursive_mutex | STL class |
| Cdx::driver< device_id_t, decltype(device_t::preference)> | |
| Cdx::driver< decltype(id), preference > | |
| Cdx::driver< decltype(id), cf::preference > | |
| Cdx::driver< decltype(_device_t::id), decltype(_device_t::preference)> | |
| Cdx::driver< decltype(device<>::id), decltype(device<>::preference)> | |
| Cdx::driver< decltype(id), dx::preference > | |
| Cdx::stream::device< dx::stream::control< dx::proxy::device< preference_t > >, desc_t, stream_t > | |
| Cdx::stream::device< dx::stream::control< usb::device< preference_t > >, desc_t, stream_t > | |
| Cdx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t > | |
| Cdx::stream::device< dx::stream::control< dx::device<::AudioObjectID, preference_t > >, desc_t, stream_t > | |
| Cdx::stream::device< dx::stream::control< dx::device<::MIDIDeviceRef, preference_t > >, desc_t, stream_t > | |
| Cdx::stream::device< dx::stream::control< dx::device< dx::guid, preference_t > >, desc_t, stream_t > | |
| Cdx::stream::device< dx::stream::control< dx::device< dx::guid, preference > >, desc, stream< device< desc, preference, stream > > > | |
| Cdx::stream::device< dx::stream::control< dx::device<::AudioObjectID, cf::preference > >, dx::virtuel::stream::desc, dx::stream::stream< device< dx::virtuel::stream::desc, cf::preference, dx::stream::stream > > > | |
| Cdx::stream::device< dx::stream::control< dx::device<::AudioObjectID, cf::preference > >, dx::virtuel::stream::desc, stream< device< dx::virtuel::stream::desc, cf::preference, stream > > > | |
| Cdx::stream::device< dx::stream::control< dx::device<::MIDIDeviceRef, cf::preference > >, desc, stream< device< desc, cf::preference, stream > > > | |
| Cdx::stream::device< dx::stream::control< dx::proxy::device< dx::preference > >, dx::stream::desc<>, stream< device< dx::stream::desc<>, dx::preference, stream > > > | |
| Cdx::stream::device< dx::stream::control< dx::device< std::string, preference > >, desc, stream< device< desc, preference, stream > > > | |
| Cdx::stream::device<> | |
| Cdx::stream::device< dx::stream::control< usb::device< dx::preference > >, desc_t, pipe< device< desc_t, dx::preference, pipe > > > | |
| Cdx::stream::device< dx::stream::control< dx::device< std::string, dx::preference > >, desc, dx::stream::shared::stream< device< desc, dx::preference, dx::stream::shared::stream > > > | |
| Cdx::stream::device< dx::stream::control< dx::device< std::string, preference > >, desc, dx::stream::stream< device< desc, preference, dx::stream::stream > > > | |
| Cdx::stream::device< desc, preference, dx::stream::stream > | |
| Cdx::driver< device_id_t, preference_t > | Abstract base driver interface class This is the abstract base interface to a driver |
| Cdx::stream::device< super_device_t, _desc_t, _stream_t > | |
| Cstd::streambuf | |
| Cdx::redirect::eventlog< type_t > | |
| Cdx::redirect::indent::streambuf | Indented streambuf |
| Cdx::redirect::log | Redirect stdout to unified logging |
| Cdx::redirect::syslog | Redirect stdout to syslog |
| Cstd::thread | STL class |
| Cdx::clock< typename device_t::event_t > | |
| Cdx::clock< device_t::event_t > | |
| Cdx::stream::engine< device_t, pin_t, driver_t > | |
| Cdx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t > | Generic streaming engine |
| Cdx::clock< dx::event< dx::kernel > > | |
| Ccf::runloop | |
| Cio::port | Notification port |
| Cdx::clock< event_t, clock_t > | |
| Cdx::coremidi::server::pin< stream_pin_t > | |
| Cdx::coremidi::stream< device_t, circular_t > | |
| Cdx::usb::stream::pipe< device_t, circular_t, stream_t > | |
| Cstd::true_type | |
| Cdx::is_dx_iterator< type_t, std::void_t< typename type_t::dx_iterator_tag > > | |
| Cdx::is_initializer_list< std::initializer_list< type_t > > | |
| Cdx::is_smart_pointer< std::shared_ptr< type_t > > | |
| Cdx::is_smart_pointer< std::unique_ptr< type_t, deleter_t > > | |
| Cdx::is_smart_pointer< std::weak_ptr< type_t > > | |
| Cdx::promoting< preference_t, std::void_t< decltype(preference_t::listen)> > | |
| Cdx::test::device< super_device_t >::has_license< type_t, decltype((void) type_t::license, void())> | |
| Cstd::tuple | |
| Cdx::gui::aggregate< image, label, button > | |
| Cdx::gui::aggregate< label, direction< device >, label, power2< juce::String > > | |
| Cdx::gui::aggregate< label, samplerate > | |
| Cdx::gui::aggregate< label, power2< juce::String > > | |
| Cdx::gui::aggregate< component_t > | |
| Cdx::select< parsers_t > | Select from aggregated drivers |
| Cstream::engine< device< super_device_t >, audio_pin_t, dx::proxy::driver< device< super_device_t > >, int32_t > | |
| Cdx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t > | |
| Cstream_desc_t | |
| Cdxd::portcls::miniport< stream_desc_t > | Portcls::miniport |
| Cdxd::portcls::stream< circular_t, bus_t, stream_desc_t > | Portcls::stream base class |
| Cdxd::wavert::stream< stream_desc_t > | Wavert::stream: cyclic WaveRT buffer with client notifications |
| Cstream_pin_t | |
| Cdx::coreaudio::server::pin< stream_pin_t > | |
| Cdx::coremidi::server::pin< stream_pin_t > | |
| Cstream_pin_t::device_t | |
| Cdx::coremidi::server::device< stream_pin_t > | CoreMIDI device |
| Cstream_t::stream_desc | |
| Cdxd::portcls::miniport< stream_t::stream_desc > | |
| Csuper_device_t | |
| Cdx::service::device< super_device_t > | |
| Cdx::service::device< dx::preference > | |
| Cdx::stream::device<> | |
| Cdx::service::device< preference_t > | Device - hosts a per-device pipe::server, keyed by puuid, separate from the driver-level control pipe Each connected client is represented by a user_client instance holding a std::shared_ptr<device>, so the device stays alive for as long as any client stays connected to it. conclude() stops that pipe before calling super::conclude(); since pipe::server::stop() unconditionally joins every instance - connected or not - this releases every user_client's device reference synchronously, within the same call. A caller holding the last other std::shared_ptr<device> (e.g. map::driver::remove()) is therefore guaranteed to reach a zero refcount, and run the device's destructor, before conclude() returns - independent of any further pipe activity. This is what lets a deferred cleanup step tied to the device's own destruction (e.g. the Windows registry preference's schedule_erase, dx_registry.h) complete within the same remove() call instead of depending on a future connection |
| Cdx::stream::device< super_device_t, _desc_t, _stream_t > | |
| Cdx::test::device< super_device_t > | |
| Csuper_stream_t | |
| Cdx::stream::stream< device_t, circular_t, super_stream_t, event_t > | |
| Cthread_time_constraint_policy_data_t | |
| Cdx::thread::prio::realtime | Thread::prio::realtime |
| Cdx::clock< typename device_t::event_t > | |
| Cdx::clock< device_t::event_t > | |
| Cdx::clock< dx::event< dx::kernel > > | |
| Cdx::clock< event_t, clock_t > | |
| Ctree_t | |
| Cdx::key_value_tree< tree_t > | Hierarchical key/value navigation over a flat persistent store |
| Ctypename stream_t::stream_desc | |
| Cdxd::portcls::miniport< typename stream_t::stream_desc > | |
| CUNICODE_STRING | |
| Cdxd::wdm::unicode< max_length > | WDM unicode string helper |
| CUSBD_PIPE_INFORMATION | |
| Cdxd::usb_device::pipe | IOKit: USB pipe class |
| Cdxd::usb_stream_device::stream | USB stream |
| CwxApp | |
| Cdx::gui::cpl< driver_t > | Dx::gui::cpl wxWidgets counterpart of the juce dx::gui::cpl application shell: a resizable window holding a tree of the driver's devices (with "+"/"-" buttons to create/destroy pod devices), a File/Debug/Help menu bar mirroring the juce interface's New/Open/Import/Save/Save As/Recent/Exit, Logging and About, and the exception hierarchy dialog above for uncaught exceptions |
| CwxButton | |
| Cdx::gui::button | |
| CwxCheckBox | |
| Cdx::gui::checkbox | |
| CwxComboBox | |
| Cdx::gui::box< item_t > | |
| Cdx::gui::box< int > | |
| Cdx::gui::box< item_t > | Dx::gui::box A read-only dropdown of (label, value) pairs, reporting the selected value |
| CwxDialog | |
| Cdx::gui::exception_dialog | Dx::gui::exception_dialog wxWidgets counterpart of the juce interface's exception hierarchy dialog: shows a dx::exception and its chain of causes (frame, comment, what()+error code, file:line, function) as a navigable tree, instead of collapsing it into a single message string |
| CwxPanel | |
| Cdx::gui::item< component > | |
| Cdx::gui::item< label > | |
| Cdx::gui::item< checkbox > | |
| Cdx::gui::item< aggregate< image, label, button > > | |
| Cdx::gui::item< aggregate< label, samplerate > > | |
| Cdx::gui::item< aggregate< label, power2< juce::String > > > | |
| Cdx::gui::item< aggregate< label, direction< device >, label, power2< juce::String > > > | |
| Cdx::gui::bar | Dx::gui::bar A row of independently toggling buttons, reporting (id, state) on change |
| Cdx::gui::item< component_t > | Dx::gui::item wx counterpart of the juce interface's dx::gui::item<component_t>: one row of a single, continuously expandable outline. Every device and every one of its stream/pin/clock/... rows is an item, nested directly inside its parent item and indented beneath it, showing its own controls inline via content - mirroring juce's TreeView design, where wx has no equivalent of an arbitrary Component hosted per tree row (wxTreeCtrl cannot host child controls), so the outline is built here from plain wxPanel rows in nested box sizers instead |
| CwxScrolledWindow | |
| Cdx::gui::cpl< driver_t >::frame::panel::scroller | |
| CwxStaticBitmap | |
| Cdx::gui::image | |
| CwxStaticText | |
| Cdx::gui::label | |
| CwxTextCtrl | |
| Cdx::gui::text | Dx::gui::text An editable single line text field, committing on Enter or on losing focus |
