| ►C_cfg_dropdown_history_base | |
| Ccfg_dropdown_history | |
| Ccfg_dropdown_history_mt | |
| C_config_object_fixed_impl_switch< p_size, isConst > | |
| ►Ctype | |
| ►Cservice_impl_single_t< _config_object_fixed_impl_switch< p_size, isConst >::type > | |
| ►Cservice_factory_single_transparent_t< _config_object_fixed_impl_switch< p_size, isConst >::type > | |
| Cconfig_object_fixed_factory_t< p_size, isConst > | |
| ►Cconfig_object_fixed_factory_t< 1, isConst > | |
| Cconfig_object_bool_factory_t< isConst > | |
| ►Cconfig_object_fixed_factory_t< sizeof(T), isConst > | |
| Cconfig_object_int_factory_t< T, isConst > | |
| C_config_object_fixed_impl_switch< p_size, false > | |
| C_config_object_fixed_impl_switch< p_size, true > | |
| ►C_critical_section_base | |
| Ccritical_section | |
| Ccritical_section_static | |
| C_IsTypeByte< TVal > | |
| C_meta_table_enum_wrapper | |
| C_meta_table_enum_wrapper_RG | |
| C_service_by_guid_data_container< what > | |
| C_stream_reader_formatter_translator< isBigEndian > | |
| C_stream_writer_formatter_translator< isBigEndian > | |
| ►C_t_base | |
| ►CCWindowFixSEH< _t_base > | |
| Cwindow_service_impl_t< _t_base > | Special service_impl_t replacement for service classes that also implement ATL/WTL windows |
| ►Cabort_callback | |
| Cdead_item_filter | |
| Calbum_art_extractor_instance_fileref::t_fileref | |
| Cpfc::alloc_hybrid< p_width, alloc_fast > | |
| Cpfc::alloc_hybrid< p_width, pfc::alloc_fast > | |
| ►Capp_close_blocking_task | An interface encapsulating a task preventing the foobar2000 application from being closed. Instances of this class need to be registered using app_close_blocking_task_manager methods.
Implementation: it's recommended that you derive from app_close_blocking_task_impl class instead of deriving from app_close_blocking_task directly, it manages registration/unregistration behind-the-scenes |
| Capp_close_blocking_task_impl | Helper; implements standard functionality required by app_close_blocking_task implementations - registers/unregisters the task on construction/destruction |
| Capp_close_blocking_task_impl_dynamic | |
| Cpfc::array_staticsize_t< t_uint8 > | |
| Cpfc::array_t< audio_sample, pfc::alloc_fast_aggressive > | |
| Cpfc::array_t< CDialogResizeHelper::Param > | |
| Cpfc::array_t< char *, alloc_fast > | |
| Cpfc::array_t< char > | |
| Cpfc::array_t< char, pfc::alloc_standard > | |
| Cpfc::array_t< char, pfc::pfc::alloc_fast_aggressive > | |
| Cpfc::array_t< char, t_alloc > | |
| Cpfc::array_t< dialog_resize_helper::param > | |
| Cpfc::array_t< dsp_preset_impl *, alloc_fast > | |
| Cpfc::array_t< file_info_ > | |
| Cpfc::array_t< file_info_impl > | |
| Cpfc::array_t< GUID, alloc_fast > | |
| ►Cpfc::array_t< HWND, pfc::alloc_hybrid< p_width, alloc_fast >::template alloc > | |
| Cpfc::array_hybrid_t< HWND, p_fixed_count, alloc_fast > | |
| Cpfc::array_t< info_entry, pfc::alloc_fast > | |
| Cpfc::array_t< item, alloc_fast > | |
| Cpfc::array_t< menu_helpers::guid_to_name_table::entry > | |
| Cpfc::array_t< menu_helpers::name_to_guid_table::entry > | |
| ►Cpfc::array_t< meta_entry, pfc::alloc_hybrid< p_width, pfc::alloc_fast >::template alloc > | |
| Cpfc::array_hybrid_t< meta_entry, 10, pfc::alloc_fast > | |
| Cpfc::array_t< metadb_io_hintlist::t_entry, pfc::alloc_fast > | |
| Cpfc::array_t< pfc::pfc::string8_t, pfc::pfc::alloc_fast > | |
| Cpfc::array_t< pfc::rcptr_t< audio_chunk >, alloc_fast > | |
| Cpfc::array_t< pfc::rcptr_t< foobar2000_io::directory_callback_impl::t_entry >, alloc_fast > | |
| Cpfc::array_t< pfc::string, alloc_fast > | |
| Cpfc::array_t< pfc::string8 > | |
| ►Cpfc::array_t< pfc::string_simple, pfc::alloc_hybrid< p_width, pfc::alloc_fast >::template alloc > | |
| Cpfc::array_hybrid_t< pfc::string_simple, 1, pfc::alloc_fast > | |
| Cpfc::array_t< playlist_dataobject_desc_impl::entry > | |
| Cpfc::array_t< RECT > | |
| Cpfc::array_t< service_ptr_t > | |
| Cpfc::array_t< service_ptr_t< metadb_handle >, t_alloc > | |
| Cpfc::array_t< service_ptr_t< T >, t_alloc > | |
| Cpfc::array_t< size_t, pfc::pfc::alloc_fast > | |
| ►Cpfc::array_t< T *, pfc::alloc_hybrid< p_width, alloc_fast >::template alloc > | |
| Cpfc::array_hybrid_t< T *, p_fixed_count, alloc_fast > | |
| Cpfc::array_t< t_char > | |
| Cpfc::array_t< t_char, t_alloc > | |
| ►Cpfc::array_t< t_item, pfc::alloc_hybrid< p_width, t_alloc >::template alloc > | |
| Cpfc::array_hybrid_t< t_item, p_fixed_count, t_alloc > | |
| Cpfc::array_hybrid_t< t_item, p_width, t_alloc > | |
| Cpfc::array_t< t_item, t_alloc > | |
| ►Cpfc::array_t< t_object *, pfc::alloc_hybrid< p_width, alloc_fast >::template alloc > | |
| Cpfc::array_hybrid_t< t_object *, p_fixed_count, alloc_fast > | |
| Cpfc::array_t< t_size > | |
| Cpfc::array_t< t_uint32 > | |
| Cpfc::array_t< t_uint8 > | |
| Cpfc::array_t< t_uint8, pfc::alloc_fast > | |
| Cpfc::array_t< t_uint8, pfc::alloc_fast_aggressive > | |
| Cpfc::array_t< t_uint8, t_alloc > | |
| Cpfc::array_t< TObj, alloc_fast > | |
| Cpfc::array_t< uint8_t * > | |
| Cpfc::array_t< wchar_t, t_alloc > | |
| ►Caudio_chunk | Interface to container of a chunk of audio data. See audio_chunk_impl for an implementation |
| Caudio_chunk_impl_t< container_t > | Implementation of audio_chunk. Takes pfc allocator template as template parameter |
| ►Caudio_chunk_memref_impl | Implements const methods of audio_chunk only, referring to an external buffer. For temporary use only (does not maintain own storage), e.g.: somefunc( audio_chunk_temp_impl(mybuffer,....) ); |
| Caudio_chunk_partial_ref | |
| Caudio_chunk::spec_t | |
| Cpfc::avltree_t< CWindow > | |
| Cpfc::avltree_t< ImplementBumpableElem * > | |
| Cpfc::avltree_t< pfc::string, pfc::string::comparatorCaseInsensitiveASCII > | |
| Cpfc::avltree_t< t_size > | |
| Cpfc::avltree_t< t_storage, comparator_wrapper > | |
| ►Cbaseclass | |
| Cinput_postprocessed< baseclass > | Generic template to add decode_postprocessor support to your input class. Works with both single-track and multi-track inputs |
| Cbitreader_helper::bitreader | |
| Cbitreader_helper::bitreader_fromfile | |
| Cbitreader_helper::bitreader_limited | |
| Cc_insync | |
| CcallInMainThread | |
| CcallInMainThreadHelper | Helper class to call methods of your class (host class) in main thread with convenience.
Deals with the otherwise ugly scenario of your class becoming invalid while a method is queued.
Have this as a member of your class, then use m_mthelper.add( this, somearg ) ; to defer a call to this->inMainThread(somearg).
If your class becomes invalid before inMainThread is executed, the pending callback is discarded.
You can optionally call shutdown() to invalidate all pending callbacks early (in a destructor of your class - without waiting for callInMainThreadHelper destructor to do the job.
In order to let callInMainThreadHelper access your private methods, declare friend class callInMainThread |
| ►CCBrushHandle | |
| CCDCBrush | |
| ►CCButton | |
| CCCheckBox | |
| CCClipboardOpenScope | |
| ►CCContainedWindowT | |
| CCContainedWindowSimpleT< TBase > | |
| CCContainedWindowSimpleT< CToolTipCtrl > | |
| CCEditNoEnterEscSteal | |
| CCEditNoEscSteal | |
| CCStaticSeparator | |
| ►CCStaticThemed | |
| CCStaticMainInstruction | |
| ►CCDC | |
| CCBackBuffer | |
| ►CCDialogImpl | |
| CCDialogWithTooltip< T > | |
| CCEmbeddedDialog | |
| CCMyDSPPopup | |
| CCMyPreferences | |
| CCPlaybackStateDemo | |
| ►CCDialogResizeHelper | |
| CCDialogResizeHelperTracking< TTracker > | |
| CCDialogResizeHelper::Param | |
| CCDLL | |
| ►CCF::CallForwarder< TWhat > | |
| CCF::CallForwarderMaster< TWhat > | |
| ►Ccfg_var_reader | Reader part of cfg_var object. In most cases, you should use cfg_var instead of using cfg_var_reader directly |
| Ccfg_objListImporter< TObj, TImport > | |
| ►Ccfg_var | Base class for configuration variable classes; provides self-registration mechaisms and methods to set/retrieve configuration data; those methods are automatically called for all registered instances by backend when configuration file is being read or written.
Note that cfg_var class and its derivatives may be only instantiated statically (as static objects or members of other static objects), NEVER dynamically (operator new, local variables, members of objects instantiated as such) |
| Ccfg_dsp_chain_config | |
| Ccfg_guidlist | |
| Ccfg_int_t< t_inttype > | Generic integer config variable class. Template parameter can be used to specify integer type to use.
Note that cfg_var class and its derivatives may be only instantiated statically (as static objects or members of other static objects), NEVER dynamically (operator new, local variables, members of objects instantiated as such) |
| Ccfg_int_t< bool > | |
| Ccfg_int_t< t_uint64 > | |
| Ccfg_obj< TObj > | |
| Ccfg_objList< TObj > | |
| Ccfg_objListEx< TList > | |
| Ccfg_objMap< TMap > | |
| Ccfg_string | String config variable. Stored in the stream with int32 header containing size in bytes, followed by non-null-terminated UTF-8 data.
Note that cfg_var class and its derivatives may be only instantiated statically (as static objects or members of other static objects), NEVER dynamically (operator new, local variables, members of objects instantiated as such) |
| Ccfg_string_mt | |
| Ccfg_struct_t< t_struct > | Struct config variable template. Warning: not endian safe, should be used only for nonportable code.
Note that cfg_var class and its derivatives may be only instantiated statically (as static objects or members of other static objects), NEVER dynamically (operator new, local variables, members of objects instantiated as such) |
| Ccfg_window_placement | |
| Ccfg_window_size | |
| CcfgDialogPosition | |
| CcfgWindowSize | |
| Cconfig_object_fixed_impl_t< p_size > | |
| Cconfig_object_impl | |
| ►Ccfg_var_writer | Writer part of cfg_var object. In most cases, you should use cfg_var instead of using cfg_var_writer directly |
| Ccfg_var | Base class for configuration variable classes; provides self-registration mechaisms and methods to set/retrieve configuration data; those methods are automatically called for all registered instances by backend when configuration file is being read or written.
Note that cfg_var class and its derivatives may be only instantiated statically (as static objects or members of other static objects), NEVER dynamically (operator new, local variables, members of objects instantiated as such) |
| ►CcfgDialogPositionData | |
| CcfgDialogPosition | |
| CcfgDialogPositionData::DeOverlapState | |
| CcfgDialogPositionTracker | |
| ►CcfgWindowSizeTracker | |
| CcfgDialogSizeTracker | |
| CCGlobalLockScope | |
| CCGlobalLockScopeT< TItem > | |
| Cpfc::chain_list_v2_t< event_logger_recorder_impl::entry_t > | |
| Cpfc::chain_list_v2_t< pfc::rcptr_t > | |
| Cpfc::chain_list_v2_t< t_dsp_chain_entry > | |
| Cpfc::chain_list_v2_t< TWhat > | |
| ►Cchapter_list | Interface for object storing list of chapters |
| Cchapter_list_impl_t< file_info_ > | Implements chapter_list |
| Cpfc::stringcvt::char_buffer_t< char > | |
| Cpfc::stringcvt::char_buffer_t< char, pfc::pfc::alloc_fast_aggressive > | |
| Cpfc::stringcvt::char_buffer_t< char, t_alloc > | |
| Cpfc::stringcvt::char_buffer_t< wchar_t, t_alloc > | |
| ►CCImageList | |
| CCImageListContainer | |
| ►Cclass_t | |
| Cservice_impl_explicitshutdown_t< class_t > | Alternate version of service_impl_t<> - calls this->service_shutdown() instead of delete this.
For special cases where selfdestruct on zero refcount is undesired |
| CClipboardHelper::OpenScope | |
| CCloseHandleScope | |
| ►CCMessageMap | |
| CCContainedWindowSimpleT< TBase > | |
| CCContainedWindowSimpleT< CToolTipCtrl > | |
| CCEditNoEnterEscSteal | |
| CCEditNoEscSteal | |
| CCMessageMapDummy | |
| CCStaticSeparator | |
| CCStaticThemed | |
| CCModelessDialogEntry | |
| CCMutex | |
| CCMutexScope | |
| CThreadUtils::CObjectQueue< pfc::rcptr_t > | |
| CCoInitializeScope | |
| ►Cpfc::combine_traits< pfc::traits_vtable, pfc::traits_t< pfc::array_t< char, t_alloc > > > | |
| Cpfc::traits_t< string8_t< t_alloc > > | |
| ►Cpfc::combine_traits< traits_t< alloc< item > >, traits_vtable > | |
| Cpfc::traits_t< list_t< item, alloc > > | |
| ►Cpfc::combine_traits< traits_t< pfc::string_simple >, traits_t< file_info_impl_utils::meta_value_array > > | |
| ►Cpfc::traits_combined< pfc::string_simple, file_info_impl_utils::meta_value_array > | |
| Cpfc::traits_t< file_info_impl_utils::meta_entry > | |
| ►Cpfc::combine_traits< traits_t< t_alloc >, traits_t< alloc_fixed< p_width >::template alloc< t_item > > > | |
| ►Cpfc::traits_combined< t_alloc, alloc_fixed< p_width >::template alloc< t_item > > | |
| Cpfc::traits_t< typename alloc_hybrid< p_width, t_alloc >::template alloc< t_item > > | |
| ►Cpfc::combine_traits< traits_t< type1 >, traits_t< type2 > > | |
| Cpfc::traits_combined< type1, type2 > | |
| Ccomparator_service_guid | |
| Ccomparator_stricmp_utf8 | |
| ►Ccompletion_notify_receiver | Helper base class for classes that manage nonblocking tasks and get notified back thru completion_notify interface |
| CCSimpleThread | IMPORTANT: all classes derived from CSimpleThread must call AbortThread()/WaitTillThreadDone() in their destructors, to avoid object destruction during a virtual function call! |
| ►CInPlaceEdit::CTableEditHelperV2 | |
| CInPlaceEdit::CTableEditHelperV2_ListView | |
| Cconfig_object_int_factory_t< T, isConst >::t_initval | |
| Cconsole::timer_scope | |
| Ccontextmenu_groups | |
| ►Ccontextmenu_item_node | |
| Ccontextmenu_item_node_leaf | |
| Ccontextmenu_item_node_popup | |
| ►Ccontextmenu_item_node_root | |
| ►Ccontextmenu_item_node_root_leaf | |
| Ccontextmenu_item_simple::contextmenu_item_node_impl | |
| Ccontextmenu_item_node_root_popup | |
| Ccontextmenu_item_node_separator | |
| Ccontextmenu_node | |
| CCoTaskMemObject< TPtr > | |
| ►CCPenHandle | |
| CCDCPen | |
| CCPopupTooltipMessage | |
| CCPowerRequest | |
| CCPowerRequestAPI | |
| CCSRWlock | |
| CCSRWorCS | |
| CCThemeT< managed > | |
| CCThemeT< true > | |
| CCTypableWindowScope | |
| Ccue_creator::t_entry | |
| Ccue_parser::cue_entry | |
| Ccue_parser::embeddedcue_metadata_manager | |
| Ccue_parser::input_wrapper_cue_t< t_base > | |
| Ccue_parser::track_record | |
| Ccuesheet_format_index_time | |
| CCWavWriter | |
| CCWindowClassUnregisterScope | |
| ►CCWindowImpl | |
| CCFlashWindow | |
| ►CCMenuSelectionReceiver | |
| CCMenuDescriptionHybrid | |
| CCMenuDescriptionMap | |
| CCMenuSelectionReceiver_UiElement | |
| CCMyElemWindow | |
| CDCClipRgnScope | |
| CDCStateScope | |
| Cdecode_postprocessor | Helper class for managing decode_postprocessor_instance objects. See also: input_postprocessed |
| Cdialog_helper::dialog | |
| Cdialog_helper::dialog_modal | This class is meant to be instantiated on-stack, as a local variable. Using new/delete operators instead or even making this a member of another object works, but does not make much sense because of the way this works (single run() call) |
| Cdialog_helper::dialog_modeless | This class is meant to be used with new/delete operators only. Destroying the window - outside create() / WM_INITDIALOG - will result in object calling delete this. If object is deleted directly using delete operator, WM_DESTROY handler may not be called so it should not be used (use destructor of derived class instead). Classes derived from dialog_modeless must not be instantiated in any other way than operator new() |
| Cdialog_helper::dialog_modeless_v2 | |
| Cdialog_resize_helper | |
| Cdialog_resize_helper::param | |
| ►Cdropped_files_data | Class used for async processing of IDataObject. Content of IDataObject can be dumped into dropped_files_data without any time-consuming operations - won't block calling app when used inside drag&drop handler - and actual time-consuming processing (listing directories and reading infos) can be done later.
|
| Cdropped_files_data_impl | Implementation of dropped_files_data |
| ►Cdsp_chain_config | |
| Cdsp_chain_config_impl | |
| ►Cdsp_chunk_list | Interface to a DSP chunk list. A DSP chunk list object is passed to the DSP chain each time, since DSPs are allowed to remove processed chunks or insert new ones |
| Cdsp_chunk_list_impl | |
| Cdsp_manager | Helper class for running audio data through a DSP chain |
| Cdsp_manager::t_dsp_chain_entry | |
| ►Cdsp_preset | |
| Cdsp_preset_impl | |
| Cdsp_preset_edit_callback | |
| Cduration_counter | Duration counter class - accumulates duration using sample values, without any kind of rounding error accumulation |
| Cdynamic_bitrate_helper | |
| CEnableWindowScope | |
| Cevent_logger_recorder_impl::entry_t | |
| ►Cfile | |
| ►Cfile_chain | |
| Cfile_chain_readonly | |
| Cfile_win32_wrapper_overlapped_t< p_writeable > | |
| Cfile_win32_wrapper_t< p_seekable, p_writeable > | |
| ►Cfile_info | Main interface class for information about some playable object |
| Cfile_info_const_impl | Special implementation of file_info that implements only const and copy methods. The difference between this and regular file_info_impl is amount of resources used and speed of the copy operation |
| Cfile_info_impl | Implements file_info |
| Cfile_info_const_impl::info_entry | |
| Cfile_info_const_impl::meta_entry | |
| Cfile_info_impl_utils::info_entry | |
| Cfile_info_impl_utils::info_storage | |
| Cfile_info_impl_utils::meta_entry | |
| Cfile_info_impl_utils::meta_storage | |
| Cfile_info_record_helper::__file_info_record__info__enumerator | |
| Cfile_info_record_helper::__file_info_record__meta__enumerator | |
| Cfile_info_record_helper::file_info_record | |
| Cfile_move_helper | |
| ►Cfile_operation_callback_dynamic | New in 0.9.5 |
| Cfile_operation_callback_dynamic_impl_base | New in 0.9.5 |
| Cfile_path_canonical | |
| Cfile_path_display | |
| ►Cfile_readonly | |
| ►Creader_bigmem | |
| Creader_bigmem_mirror | |
| Creader_limited | |
| ►Creader_membuffer_base | |
| Creader_membuffer_mirror | |
| Creader_membuffer_simple | |
| Cseekabilizer | |
| Cfile_win32_helpers::createFileData_t | |
| CfileRestorePositionScope | |
| Cfoobar2000_api | |
| Cfoobar2000_client | |
| Cfoobar2000_component_globals | |
| ►Cfoobar2000_io::abort_callback | This class is used to signal underlying worker code whether user has decided to abort a potentially time-consuming operation.
It is commonly required by all filesystem related or decoding-related operations.
Code that receives an abort_callback object should periodically check it and abort any operations being performed if it is signaled, typically throwing exception_aborted.
See abort_callback_impl for an implementation |
| Cfoobar2000_io::abort_callback_dummy | Dummy abort_callback that never gets aborted.
Slightly more efficient than the regular one especially when you need to regularly create temporary instances of it |
| Cfoobar2000_io::abort_callback_impl | Implementation of abort_callback interface |
| Cfoobar2000_io::archive_callback | |
| ►Cfoobar2000_io::directory_callback | |
| Cfoobar2000_io::directory_callback_impl | |
| Cfoobar2000_io::directory_callback_retrieveList< t_list > | |
| Cfoobar2000_io::directory_callback_retrieveListEx< t_list > | |
| Cfoobar2000_io::directory_callback_retrieveListRecur< t_list > | |
| Cfoobar2000_io::directory_callback_impl::t_entry | |
| Cfoobar2000_io::format_filetimestamp | Warning: this formats according to system timezone settings, created strings should be used for display only, never for storage |
| Cfoobar2000_io::format_filetimestamp_utc | |
| ►Cfoobar2000_io::stream_reader | Generic interface to read data from a nonseekable stream. Also see: stream_writer, file.
Error handling: all methods may throw exception_io or one of derivatives on failure; exception_aborted when abort_callback is signaled |
| ►Cfoobar2000_io::file | A class providing abstraction for an open file object, with reading/writing/seeking methods. See also: stream_reader, stream_writer (which it inherits read/write methods from).
Error handling: all methods may throw exception_io or one of derivatives on failure; exception_aborted when abort_callback is signaled |
| Cfoobar2000_io::file_cached | Extension for cached file access - allows callers to know that they're dealing with a cache layer, to prevent cache duplication |
| Cfoobar2000_io::file_dynamicinfo | Extension for shoutcast dynamic metadata handling |
| ►Cfoobar2000_io::stream_writer | Generic interface to write data to a nonseekable stream. Also see: stream_reader, file.
Error handling: all methods may throw exception_io or one of derivatives on failure; exception_aborted when abort_callback is signaled |
| Cfoobar2000_io::file | A class providing abstraction for an open file object, with reading/writing/seeking methods. See also: stream_reader, stream_writer (which it inherits read/write methods from).
Error handling: all methods may throw exception_io or one of derivatives on failure; exception_aborted when abort_callback is signaled |
| Cfoobar2000_io::t_filestats | Stores file stats (size and timestamp) |
| Cformat_hresult | |
| Cformat_rg_gain | |
| Cformat_rg_peak | |
| Cformat_win32_error | |
| ►Cfpu_control | |
| Cfpu_control_default | |
| Cfpu_control_flushdenormal | |
| Cfpu_control_roundnearest | |
| CfullFileBuffer | |
| CGUID | |
| Chasher_md5_result | |
| Chasher_md5_state | |
| ►CIDataObject | |
| CIDataObjectUtils::CDataObjectBase | |
| CIDataObjectUtils::comparator_FORMATETC | |
| CIDataObjectUtils::ReleaseStgMediumScope | |
| ►Cidle_handler | |
| Cidle_handler_impl_base | |
| CInPlaceEdit::CTableEditHelper | |
| Cinput_cuesheet_factory_t< t_input_impl, t_flags > | Wrapper template for generating embedded cuesheet enabled inputs. t_input_impl is a singletrack input implementation (see input_singletrack_impl for method declarations). To declare an embedded cuesheet enabled input, change your input declaration from input_singletrack_factory_t<myinput> to input_cuesheet_factory_t<myinput> |
| Cinput_helper | |
| Cinput_helper::decodeOpen_t | |
| Cinput_helper_cue | |
| Cinput_impl | This is a class that just declares prototypes of functions that each input needs to implement. See input_decoder / input_info_reader / input_info_writer interfaces for full descriptions of member functions. Since input implementation class is instantiated using a template, you don't need to derive from input_impl as virtual functions are not used on implementation class level. Use input_factory_t template to register input class based on input_impl |
| Cinput_info_read_helper | |
| Cinput_raw | |
| Cinput_singletrack_impl | This is a class that just declares prototypes of functions that each non-multitrack-enabled input needs to implement. See input_decoder / input_info_reader / input_info_writer interfaces for full descriptions of member functions. Since input implementation class is instantiated using a template, you don't need to derive from input_singletrack_impl as virtual functions are not used on implementation class level. Use input_singletrack_factory_t template to register input class based on input_singletrack_impl |
| Cinput_wrapper_singletrack_t< I > | Helper used by input_singletrack_factory_t, do not use directly. Translates input_impl calls to input_singletrack_impl calls |
| ►Cpfc::int_specs_signed_t< char > | |
| Cpfc::int_specs_t< char > | |
| ►Cpfc::int_specs_signed_t< int > | |
| Cpfc::int_specs_t< int > | |
| ►Cpfc::int_specs_signed_t< long > | |
| Cpfc::int_specs_t< long > | |
| ►Cpfc::int_specs_signed_t< long long > | |
| Cpfc::int_specs_t< long long > | |
| ►Cpfc::int_specs_signed_t< short > | |
| Cpfc::int_specs_t< short > | |
| ►Cpfc::int_specs_unsigned_t< unsigned char > | |
| Cpfc::int_specs_t< unsigned char > | |
| ►Cpfc::int_specs_unsigned_t< unsigned int > | |
| Cpfc::int_specs_t< unsigned int > | |
| ►Cpfc::int_specs_unsigned_t< unsigned long > | |
| Cpfc::int_specs_t< unsigned long > | |
| ►Cpfc::int_specs_unsigned_t< unsigned long long > | |
| Cpfc::int_specs_t< unsigned long long > | |
| ►Cpfc::int_specs_unsigned_t< unsigned short > | |
| Cpfc::int_specs_t< unsigned short > | |
| ►Cpfc::int_specs_unsigned_t< wchar_t > | |
| Cpfc::int_specs_t< wchar_t > | |
| CLastErrorRevertScope | |
| ►Clibrary_callback_dynamic | |
| Clibrary_callback_dynamic_impl_base | |
| ►Clibrary_file_move_notify_ | |
| Clibrary_file_move_notify | |
| Clibrary_manager::enum_callback | Interface for use with library_manager::enum_items() |
| ►Cpfc::list_base_const_t< char * > | |
| ►Cpfc::list_base_t< char * > | |
| ►Cpfc::list_impl_t< char *, array_t< char *, alloc_fast > > | |
| ►Cpfc::list_t< char * > | |
| Cpfc::ptr_list_t< char > | |
| ►Cpfc::list_base_const_t< const char * > | |
| Cfile_list_helper::file_list_from_metadb_handle_list | |
| Cpfc::string_list_impl | |
| ►CuGetOpenFileNameMultiResult | |
| CuGetOpenFileNameMultiResult_impl | |
| ►Cpfc::list_base_const_t< const file_info * > | |
| Cmetadb_io_hintlist::metadb_io_hintlist_wrapper_part2 | |
| ►Cpfc::list_base_const_t< const T * > | |
| Cpfc::ptr_list_const_cast_t< T > | |
| ►Cpfc::list_base_const_t< dsp_preset_impl * > | |
| ►Cpfc::list_base_t< dsp_preset_impl * > | |
| ►Cpfc::list_impl_t< dsp_preset_impl *, array_t< dsp_preset_impl *, alloc_fast > > | |
| ►Cpfc::list_t< dsp_preset_impl * > | |
| Cpfc::ptr_list_t< dsp_preset_impl > | |
| Cpfc::list_base_const_t< file_info * > | |
| Cpfc::list_base_const_t< from > | |
| ►Cpfc::list_base_const_t< GUID > | |
| ►Cpfc::list_base_t< GUID > | |
| ►Cpfc::list_impl_t< GUID, array_t< GUID, alloc_fast > > | |
| ►Cpfc::list_t< GUID > | |
| Ccfg_guidlist | |
| ►Cpfc::list_base_const_t< HWND > | |
| ►Cpfc::list_base_t< HWND > | |
| ►Cpfc::list_impl_t< HWND, array_hybrid_t< HWND, p_fixed_count, alloc_fast > > | |
| Cpfc::list_hybrid_t< HWND, 2 > | |
| ►Cpfc::list_base_const_t< item > | |
| ►Cpfc::list_base_t< item > | |
| ►Cpfc::list_impl_t< item, array_t< item, alloc_fast > > | |
| Cpfc::list_t< item > | |
| ►Cpfc::list_base_const_t< metadb_handle_ptr > | |
| Cmetadb_io_hintlist::metadb_io_hintlist_wrapper_part1 | |
| Cpfc::list_base_const_t< metadb_io_hintlist::metadb_io_hintlist::t_entry > | |
| ►Cpfc::list_base_const_t< metadb_io_hintlist::t_entry > | |
| ►Cpfc::list_base_t< metadb_io_hintlist::t_entry > | |
| ►Cpfc::list_impl_t< metadb_io_hintlist::t_entry, array_t< metadb_io_hintlist::t_entry, pfc::alloc_fast > > | |
| Cpfc::list_t< metadb_io_hintlist::t_entry, pfc::alloc_fast > | |
| ►Cpfc::list_base_const_t< pfc::rcptr_t< audio_chunk > > | |
| ►Cpfc::list_base_t< pfc::rcptr_t< audio_chunk > > | |
| ►Cpfc::list_impl_t< pfc::rcptr_t< audio_chunk >, array_t< pfc::rcptr_t< audio_chunk >, alloc_fast > > | |
| Cpfc::list_t< pfc::rcptr_t< audio_chunk > > | |
| ►Cpfc::list_base_const_t< pfc::rcptr_t< foobar2000_io::directory_callback_impl::t_entry > > | |
| ►Cpfc::list_base_t< pfc::rcptr_t< foobar2000_io::directory_callback_impl::t_entry > > | |
| ►Cpfc::list_impl_t< pfc::rcptr_t< foobar2000_io::directory_callback_impl::t_entry >, array_t< pfc::rcptr_t< foobar2000_io::directory_callback_impl::t_entry >, alloc_fast > > | |
| Cpfc::list_t< pfc::rcptr_t< foobar2000_io::directory_callback_impl::t_entry > > | |
| ►Cpfc::list_base_const_t< pfc::string > | |
| ►Cpfc::list_base_t< pfc::string > | |
| ►Cpfc::list_impl_t< pfc::string, array_t< pfc::string, alloc_fast > > | |
| Cpfc::list_t< pfc::string > | |
| ►Cpfc::list_base_const_t< service_ptr_t< metadb_handle > > | |
| ►Cpfc::list_base_t< service_ptr_t< metadb_handle > > | |
| ►Cpfc::list_impl_t< service_ptr_t< metadb_handle >, array_t< service_ptr_t< metadb_handle >, t_alloc > > | |
| ►Cpfc::list_t< service_ptr_t< metadb_handle >, t_alloc > | |
| ►Cservice_list_t< metadb_handle, t_alloc > | |
| Cmetadb_handle_list_t< t_alloc > | |
| ►Cpfc::list_base_const_t< service_ptr_t< T > > | |
| ►Cpfc::list_base_t< service_ptr_t< T > > | |
| ►Cpfc::list_impl_t< service_ptr_t< T >, array_t< service_ptr_t< T >, t_alloc > > | |
| ►Cpfc::list_t< service_ptr_t< T >, t_alloc > | |
| Cservice_list_t< T, t_alloc > | |
| ►Cpfc::list_base_const_t< T * > | |
| ►Cpfc::list_base_t< T * > | |
| ►Cpfc::list_impl_t< T *, array_hybrid_t< T *, p_fixed_count, alloc_fast > > | |
| ►Cpfc::list_hybrid_t< T *, N > | |
| ►Cpfc::ptr_list_t< T, list_hybrid_t< T *, N > > | |
| Cpfc::ptr_list_hybrid_t< T, N > | |
| Cpfc::ptr_list_const_array_t< T, A > | |
| ►Cpfc::list_base_const_t< t_array::t_item > | |
| Cpfc::list_const_array_ref_t< t_array > | |
| ►Cpfc::list_base_const_t< t_filestats > | |
| Cmetadb_io_hintlist::metadb_io_hintlist_wrapper_part3 | |
| ►Cpfc::list_base_const_t< t_item > | |
| ►Cpfc::list_base_t< t_item > | |
| ►Cpfc::list_impl_t< t_item, array_hybrid_t< t_item, p_fixed_count, t_alloc > > | |
| Cpfc::list_hybrid_t< t_item, p_fixed_count, t_alloc > | |
| ►Cpfc::list_impl_t< t_item, array_t< t_item, t_alloc > > | |
| Cpfc::list_t< t_item, t_alloc > | |
| ►Cpfc::list_base_const_t< t_object * > | |
| ►Cpfc::list_base_t< t_object * > | |
| ►Cpfc::list_impl_t< t_object *, array_hybrid_t< t_object *, p_fixed_count, alloc_fast > > | |
| ►Cpfc::list_hybrid_t< t_object *, N > | |
| ►Cpfc::ptr_list_t< t_object, list_hybrid_t< t_object *, N > > | |
| Cpfc::ptr_list_hybrid_t< t_object, 4 > | |
| ►Cpfc::list_base_const_t< to > | |
| Cpfc::list_const_cast_t< to, from > | |
| ►Cpfc::list_base_const_t< TObj > | |
| ►Cpfc::list_base_t< TObj > | |
| ►Cpfc::list_impl_t< TObj, array_t< TObj, alloc_fast > > | |
| ►Cpfc::list_t< TObj > | |
| Ccfg_objList< TObj > | |
| Cmainmenu_groups | |
| Cpfc::map_t< FORMATETC, pfc::array_t< t_uint8 >, comparator_FORMATETC > | |
| Cpfc::map_t< GUID, album_art_data::ptr > | |
| Cpfc::map_t< GUID, album_art_extractor_instance_fileref::t_fileref > | |
| Cpfc::map_t< GUID, service_ptr_t > | |
| Cpfc::map_t< GUID, t_size > | |
| Cpfc::map_t< pfc::string8, pfc::string8, file_info::field_name_comparator > | |
| Cpfc::map_t< pfc::string8, t_entry, file_info::field_name_comparator > | |
| Cpfc::map_t< pfc::string8, t_meta_value, file_info::field_name_comparator > | |
| Cpfc::map_t< t_uint32, t_uint64 > | |
| Cpfc::map_t< UINT, CRect > | |
| Cpfc::map_t< unsigned, pfc::string8 > | |
| Cpfc::map_t< unsigned, service_nnptr_t > | |
| Cpfc::map_t< unsigned, track_record > | |
| Cpfc::mem_block_aligned< 16 > | |
| ►Cmem_block_container | Generic interface for a memory block; used by various other interfaces to return memory blocks while allowing caller to allocate |
| Cmem_block_container_aligned_impl< alignBytes > | |
| Cmem_block_container_aligned_incremental_impl< alignBytes > | |
| Cmem_block_container_aligned_incremental_impl< 16 > | |
| Cmem_block_container_impl_t< t_alloc > | Mem_block_container implementation |
| Cmem_block_container_ref_impl< t_ref > | |
| Cmem_block_container_temp_impl | |
| Cmem_block_manager< T > | |
| Cmem_block_manager< T >::entry | |
| Cmenu_helpers::guid_to_name_table | |
| Cmenu_helpers::guid_to_name_table::entry | |
| Cmenu_helpers::name_to_guid_table | |
| Cmenu_helpers::name_to_guid_table::entry | |
| Cmenu_helpers::name_to_guid_table::search_entry | |
| ►Cmessage_filter | |
| ►Cmessage_filter_impl_base | |
| Cmessage_filter_impl_accel | |
| Cmessage_filter_remap_f1 | |
| Cmeta_table_builder | Purpose: building a file_info metadata table from loose input without search-for-existing-entry bottleneck |
| ►Cmetadb_io_callback_dynamic | Dynamically-registered version of metadb_io_callback. See metadb_io_callback for documentation, register instances using metadb_io_v3::register_callback(). It's recommended that you use the metadb_io_callback_dynamic_impl_base helper class to manage registration/unregistration |
| Cmetadb_io_callback_dynamic_impl_base | Metadb_io_callback_dynamic implementation helper |
| Cmetadb_io_hintlist | |
| Cmetadb_io_hintlist::t_entry | |
| Cmodal_dialog_scope | The purpose of modal_dialog_scope is to help to avoid the modal dialog recursion problem. Current toplevel modal dialog handle is stored globally, so when creation of a new modal dialog is blocked, it can be activated to indicate the reason for the task being blocked |
| Cmp3_utils::TMPEGFrameInfo | |
| Cmp3header | |
| CmutexScope | |
| CNoRedrawScope | |
| CNoRedrawScopeEx | |
| COffsetWindowOrgScope | |
| COleInitializeScope | |
| CopenAudioData_t | OpenAudioData return value, see openAudioData() |
| Corder_helper | |
| Coutput_device_enum_callback | |
| CoutputCoreConfig_t | |
| Cpacket_decoder::matroska_setup | |
| Cpfc::__array_fast_helper_t< t_item > | |
| Cpfc::__array_lite_helper_t< t_item > | |
| Cpfc::__DecodeIntHelper< TInt, width, IsBigEndian > | |
| Cpfc::__DecodeIntHelper< TInt, 0, IsBigEndian > | |
| Cpfc::__DecodeIntHelper< TInt, 1, IsBigEndian > | |
| Cpfc::__EncodeIntHelper< TInt, width, IsBigEndian > | |
| Cpfc::__EncodeIntHelper< TInt, 0, IsBigEndian > | |
| Cpfc::__EncodeIntHelper< TInt, 1, IsBigEndian > | |
| Cpfc::__list_to_array_enumerator< t_array > | |
| Cpfc::__map_overwrite_wrapper< t_destination > | |
| Cpfc::__splitStringSimple_arrayWrapper< t_array > | |
| Cpfc::__splitStringSimple_calculateSubstringCount | |
| Cpfc::__splitStringSimple_listWrapper< t_list > | |
| Cpfc::_readWriteLock_scope_read | |
| Cpfc::_readWriteLock_scope_write | |
| Cpfc::_splitStringSimple_check< t_param > | |
| Cpfc::_splitStringSimple_check< char > | |
| Cpfc::_splitStringSimple_check< const char * > | |
| Cpfc::alloc_dummy< t_item > | |
| Cpfc::alloc_fast< t_item > | |
| Cpfc::alloc_fast_aggressive< t_item > | |
| Cpfc::alloc_fixed< p_width > | |
| Cpfc::alloc_fixed< p_width >::alloc< t_item > | |
| Cpfc::alloc_hybrid< p_width, t_alloc > | |
| Cpfc::alloc_hybrid< p_width, t_alloc >::alloc< t_item > | |
| Cpfc::alloc_simple< t_item > | Simple inefficient fully portable allocator |
| Cpfc::alloc_standard< t_item > | |
| Cpfc::array_2d_t< t_item, t_alloc > | |
| Cpfc::array_staticsize_t< _t_item > | Special simplififed version of array class that avoids stepping on landmines with classes without public copy operators/constructors |
| Cpfc::array_t< _t_item, t_alloc > | |
| Cpfc::assert_byte_type< t_type > | |
| Cpfc::assert_byte_type< char > | |
| Cpfc::assert_byte_type< signed char > | |
| Cpfc::assert_byte_type< unsigned char > | |
| Cpfc::assert_same_type< p_type1, p_type2 > | |
| Cpfc::assert_same_type< p_type, p_type > | |
| ►Cpfc::audio_math | |
| Cfb2k_audio_math | |
| Cpfc::avltree_t< t_storage, t_comparator > | |
| Cpfc::bigmem | |
| Cpfc::binarySearch< t_comparator > | |
| ►Cpfc::bit_array | Bit array interface class, constant version (you can only retrieve values).
Range of valid indexes depends on the context. When passing a bit_array as a parameter to some code, valid index range must be signaled independently |
| Cbit_array_and | Combines two arrays using the AND logical operator.
Valid index range is an intersection of valid index ranges of the parameter arrays |
| Cbit_array_false | |
| Cbit_array_not | Negation of another array.
Valid index range is the same as valid index range of the parameter array |
| Cbit_array_one | |
| Cbit_array_or | Combines two arrays using the OR logical operator.
Valid index range is an intersection of valid index ranges of the parameter arrays |
| Cbit_array_order_changed | Bit array that takes a permutation and signals indexes reordered by the permutation.
Valid index range same as length of the permutation |
| Cbit_array_range | |
| Cbit_array_table_t< T > | |
| Cbit_array_true | |
| Cbit_array_val | |
| Cbit_array_wrapper_permutation | |
| Cbit_array_xor | Combines two arrays using the XOR logical operator.
Valid index range is an intersection of valid index ranges of the parameter arrays |
| Cmetadb_io_hintlist::metadb_io_hintlist_wrapper_part4 | |
| Cpfc::bit_array_flatIndexList | Specialized implementation of bit_array.
Indended for scenarios where fast searching for true values in a large list is needed, combined with low footprint regardless of the amount of items. Call add() repeatedly with the true val indexes. If the indexes were not added in increasing order, call presort() when done with adding |
| ►Cpfc::bit_array_var | Bit array interface class, variable version (you can both set and retrieve values).
As with the constant version, valid index range depends on the context |
| Cbit_array_bittable | Generic variable bit_array implementation.
Needs to be initialized with requested array size before use |
| Cbit_array_var_table_t< T > | |
| Cpfc::bit_array_var_impl | Generic variable bit array implementation.
Not very efficient to handle lots of items set to true but offers fast searches for true values and accepts arbitrary indexes, contrary to bit_array_bittable. Note that searches for false values are relatively inefficient |
| ►Cpfc::bsearch_callback | |
| Cpfc::bsearch_callback_impl_permutation_t< t_container, t_compare, t_param, t_permutation > | |
| Cpfc::bsearch_callback_impl_simple_t< t_container, t_compare, t_param > | |
| Cpfc::chain_list_v2_t< _t_item > | Differences between chain_list_v2_t<> and old chain_list_t<>:
Iterators pointing to removed items as well as to items belonging to no longer existing list objects remain valid but they're no longer walkable - as if the referenced item was the only item in the list. The old class invalidated iterators on deletion instead |
| Cpfc::com_ptr_t< T > | |
| Cpfc::combine_traits< traits1, traits2 > | |
| Cpfc::comparator_array< t_comparator > | |
| Cpfc::comparator_default | For use with avltree/map etc |
| Cpfc::comparator_dual< t_primary, t_secondary > | |
| Cpfc::comparator_list< t_comparator > | |
| Cpfc::comparator_memcmp | |
| Cpfc::comparator_naturalSort | |
| Cpfc::comparator_pointer< t_comparator > | |
| Cpfc::comparator_strcmp | |
| Cpfc::comparator_stricmp_ascii | |
| ►Cpfc::const_iterator< t_item > | |
| Cpfc::iterator< t_item > | |
| Cpfc::counter | |
| Cpfc::enumerator_add_item< t_receiver > | |
| Cpfc::fdSelect | |
| Cpfc::fdSet | |
| Cpfc::fileHandle | |
| Cpfc::format_char | |
| Cpfc::format_fixedpoint | |
| Cpfc::format_float | |
| Cpfc::format_hex | |
| Cpfc::format_hex_lowercase | |
| Cpfc::format_hexdump | |
| Cpfc::format_hexdump_ex | |
| Cpfc::format_hexdump_lowercase | |
| Cpfc::format_int | |
| Cpfc::format_pad_left< t_stringbuffer > | |
| Cpfc::format_pad_right< t_stringbuffer > | |
| Cpfc::format_time | |
| Cpfc::format_time_ex | |
| Cpfc::format_uint | |
| Cpfc::hires_timer | |
| Cpfc::incrementScope< t_val > | |
| Cpfc::instance_tracker_client_t< t_object, p_server > | |
| Cpfc::instance_tracker_server_t< t_object > | |
| Cpfc::instanceTrackerV2< TClass > | |
| Cpfc::int_container_helper< t_type, p_initval > | |
| Cpfc::int_specs_signed_t< T > | |
| Cpfc::int_specs_t< T > | |
| Cpfc::int_specs_unsigned_t< T > | |
| Cpfc::is_same_type< p_type1, p_type2 > | |
| Cpfc::is_same_type< p_type, p_type > | |
| ►Cpfc::list_base_const_t< T > | |
| ►Cpfc::list_base_t< T > | |
| Cpfc::list_impl_t< T, t_storage > | |
| Cpfc::list_const_array_t< T, A > | |
| Cpfc::list_const_permutation_t< T, P > | |
| Cpfc::list_const_ptr_t< T > | |
| Cpfc::list_partial_ref_t< T > | |
| Cpfc::list_permutation_t< T > | |
| Cpfc::list_single_ref_t< T > | |
| ►Cpfc::list_base_t< T >::sort_callback | |
| Cpfc::list_base_t< T >::sort_callback_auto | |
| Cpfc::list_base_t< T >::sort_callback_impl_t< t_compare > | |
| Cpfc::list_impl_t< T, t_storage >::sort_callback_wrapper | |
| Cpfc::lores_timer | |
| Cpfc::map_t< t_storage_key, t_storage_value, t_comparator > | |
| Cpfc::map_t< t_storage_key, t_storage_value, t_comparator >::comparator_wrapper | |
| Cpfc::map_t< t_storage_key, t_storage_value, t_comparator >::enumeration_wrapper< t_callback > | |
| Cpfc::map_t< t_storage_key, t_storage_value, t_comparator >::enumeration_wrapper_var< t_callback > | |
| Cpfc::map_t< t_storage_key, t_storage_value, t_comparator >::t_retrieve_key< _t_key > | |
| Cpfc::map_t< t_storage_key, t_storage_value, t_comparator >::t_search_query< _t_key > | |
| Cpfc::map_t< t_storage_key, t_storage_value, t_comparator >::t_search_set< _t_key, _t_value > | |
| Cpfc::map_t< t_storage_key, t_storage_value, t_comparator >::t_storage | |
| Cpfc::mem_block_aligned< alignBytes > | |
| Cpfc::mem_block_aligned_incremental_t< obj_t, alignBytes > | |
| Cpfc::mem_block_aligned_t< obj_t, alignBytes > | |
| Cpfc::mutexAttr | |
| ►Cpfc::mutexBase | |
| Cpfc::mutex | |
| Cpfc::mutexRecur | |
| Cpfc::mutexRecurStatic | |
| Cpfc::mutexScope | |
| Cpfc::nix_event | |
| Cpfc::objDestructNotify | |
| ►Cpfc::objDestructNotifyData | |
| Cpfc::objDestructNotifyScope | |
| Cpfc::print_guid | |
| Cpfc::profiler_local | |
| Cpfc::profiler_static | |
| Cpfc::ptrholder_t< T, t_releaser > | Assumes t_freefunc to never throw exceptions |
| Cpfc::ptrholder_t< void, t_releaser > | |
| ►Cpfc::rc_container_base | |
| Cpfc::rc_container_t< t_object > | |
| Cpfc::rcptr_t< t_object > | |
| Cpfc::readWriteLockAttr | |
| ►Cpfc::readWriteLockBase | |
| Cpfc::readWriteLock | |
| Cpfc::refcounted_object_ptr_t< T > | |
| ►Cpfc::refcounted_object_root | |
| ►Cpfc::_list_node< t_storage > | |
| Cpfc::_avltree_node< t_storage > | |
| ►Cpfc::_list_node< t_item > | Base class for list nodes. Implemented by list implementers |
| Cpfc::__chain_list_elem< t_item > | |
| Cpfc::releaser_delete | |
| Cpfc::releaser_delete_array | |
| Cpfc::releaser_free | |
| ►Cpfc::reorder_callback | |
| Cpfc::reorder_callback_impl_delta | |
| Cpfc::reorder_callback_impl_ptr_t< T > | |
| Cpfc::reorder_callback_impl_t< t_container > | |
| Cpfc::sized_int_t< t_bytes > | |
| Cpfc::sized_int_t< 1 > | |
| Cpfc::sized_int_t< 2 > | |
| Cpfc::sized_int_t< 4 > | |
| Cpfc::sized_int_t< 8 > | |
| ►Cpfc::sort_callback | |
| Cpfc::sort_callback_impl_auto_wrap_t< t_container > | |
| Cpfc::sort_callback_impl_permutation_wrap_t< t_container, t_compare, t_permutation > | |
| Cpfc::sort_callback_impl_simple_wrap_t< t_container, t_compare > | |
| Cpfc::sort_callback_stabilizer | |
| Cpfc::static_assert_t< val > | |
| Cpfc::static_assert_t< true > | |
| Cpfc::string | New EXPERIMENTAL string class, allowing efficient copies and returning from functions.
Does not implement the string_base interface so you still need string8 in many cases.
Safe to pass between DLLs, but since a reference is used, objects possibly created by other DLLs must be released before owning DLLs are unloaded |
| ►Cpfc::string::_comparatorCommon | |
| Cpfc::string::comparatorCaseInsensitive | |
| Cpfc::string::comparatorCaseInsensitiveASCII | |
| Cpfc::string::comparatorCaseSensitive | |
| Cpfc::string_buffer | |
| Cpfc::string_directory | |
| Cpfc::string_extension | |
| Cpfc::string_part_ref | |
| ►Cpfc::string_receiver | |
| ►Cpfc::string_base | |
| Cpfc::__stringEmpty | |
| ►Cpfc::string8_t< t_alloc > | |
| Ccfg_string | String config variable. Stored in the stream with int32 header containing size in bytes, followed by non-null-terminated UTF-8 data.
Note that cfg_var class and its derivatives may be only instantiated statically (as static objects or members of other static objects), NEVER dynamically (operator new, local variables, members of objects instantiated as such) |
| Cpfc::debugLog | |
| Cpfc::format_file_size_short | |
| Cpfc::string_filename_ext | |
| Cpfc::string_base_ref | |
| Cpfc::string_fixed_t< max_length > | |
| ►Cpfc::string8_t< pfc::alloc_standard > | |
| Cpfc::string_filename | |
| Cpfc::string_fixed_t< 127 > | |
| Cpfc::string_fixed_t< 32 > | |
| Cstring_formatter_tf | |
| Cpfc::string_replace_extension | |
| Cpfc::string_simple_t< t_char > | |
| Cpfc::stringcvt::char_buffer_t< t_char, t_alloc > | |
| Cpfc::stringcvt::string_ansi_from_utf8 | |
| Cpfc::stringcvt::string_ansi_from_wide | |
| Cpfc::stringcvt::string_ascii_from_utf8 | |
| Cpfc::stringcvt::string_codepage_from_utf8 | |
| Cpfc::stringcvt::string_codepage_from_wide_t< t_alloc > | |
| Cpfc::stringcvt::string_utf8_from_ansi | |
| Cpfc::stringcvt::string_utf8_from_codepage | |
| Cpfc::stringcvt::string_utf8_from_os_ex | |
| Cpfc::stringcvt::string_utf8_from_wide_t< t_alloc > | |
| Cpfc::stringcvt::string_utf8_from_win1252_t< t_alloc > | |
| Cpfc::stringcvt::string_wide_from_ansi | |
| Cpfc::stringcvt::string_wide_from_codepage_t< t_alloc > | |
| Cpfc::stringcvt::string_wide_from_utf8_t< t_alloc > | |
| Cpfc::stringcvt::string_wide_from_win1252_t< t_alloc > | |
| Cpfc::stringcvt::string_win1252_from_utf8_t< t_alloc > | |
| Cpfc::stringcvt::string_win1252_from_wide_t< t_alloc > | |
| Cpfc::stringp | "String parameter" helper class, to use in function parameters, allowing functions to take any type of string as a parameter (const char*, string_base, string) |
| Cpfc::syncd_storage< t_object > | |
| Cpfc::syncd_storage_flagged< t_object > | |
| ►Cpfc::thread | IMPORTANT: all classes derived from thread must call waitTillDone() in their destructor, to avoid object destruction during a virtual function call! |
| CCSimpleThread | IMPORTANT: all classes derived from CSimpleThread must call AbortThread()/WaitTillThreadDone() in their destructors, to avoid object destruction during a virtual function call! |
| ►CCVerySimpleThread | IMPORTANT: all classes derived from CVerySimpleThread must call WaitTillThreadDone() in their destructor, to avoid object destruction during a virtual function call! |
| CThreadUtils::CSingleThreadWrapper< TBase, processMsgs > | |
| ►Cpfc::traits_default | |
| ►Cpfc::traits_rawobject | |
| Cpfc::traits_t< bool > | |
| Cpfc::traits_t< char > | |
| Cpfc::traits_t< double > | |
| Cpfc::traits_t< float > | |
| Cpfc::traits_t< GUID > | |
| Cpfc::traits_t< hasher_md5_result > | |
| Cpfc::traits_t< hasher_md5_state > | |
| Cpfc::traits_t< int > | |
| Cpfc::traits_t< long > | |
| Cpfc::traits_t< long long > | |
| Cpfc::traits_t< short > | |
| Cpfc::traits_t< signed char > | |
| Cpfc::traits_t< T * > | |
| Cpfc::traits_t< unsigned char > | |
| Cpfc::traits_t< unsigned int > | |
| Cpfc::traits_t< unsigned long > | |
| Cpfc::traits_t< unsigned long long > | |
| Cpfc::traits_t< unsigned short > | |
| Cpfc::traits_t< wchar_t > | |
| ►Cpfc::traits_rcptr | |
| Cpfc::traits_t< rcptr_t< T > > | |
| ►Cpfc::traits_service_ptr | |
| Cpfc::traits_t< service_nnptr_t< T > > | |
| Cpfc::traits_t< service_ptr_t< T > > | |
| ►Cpfc::traits_t< T > | |
| Cpfc::traits_t< T[p_count]> | |
| Cpfc::traits_t< refcounted_object_ptr_t< T > > | |
| Cpfc::traits_t< string > | |
| ►Cpfc::traits_t< array_t< t_char > > | |
| Cpfc::traits_t< string_simple_t< t_char > > | |
| ►Cpfc::traits_t< base > | |
| Cpfc::traits_t< ptr_list_t< item, base > > | |
| ►Cpfc::traits_t< pfc::string_simple > | |
| Cpfc::traits_t< file_info_impl_utils::info_entry > | |
| ►Cpfc::traits_t< refcounted_object_ptr_t< _list_node< t_item > > > | |
| ►Cpfc::traits_t< const_iterator< t_item > > | |
| Cpfc::traits_t< iterator< t_item > > | |
| ►Cpfc::traits_t< t_alloc< t_item > > | |
| Cpfc::traits_t< array_t< t_item, t_alloc > > | |
| ►Cpfc::traits_t< t_item > | |
| Cpfc::traits_t< typename alloc_fixed< p_width >::template alloc< t_item > > | |
| ►Cpfc::traits_default_movable | |
| Cpfc::__chain_list_iterator_traits | |
| ►Cpfc::traits_t< __array_fast_helper_t< t_item > > | |
| Cpfc::traits_t< alloc_fast< t_item > > | |
| Cpfc::traits_t< alloc_fast_aggressive< t_item > > | |
| Cpfc::traits_t< alloc_standard< t_item > > | |
| Cpfc::traits_t< alloc_simple< t_item > > | |
| Cpfc::traits_t< array_staticsize_t< t_item > > | |
| Cpfc::traits_t< avltree_t< t_storage, t_comparator > > | |
| Cpfc::traits_t< chain_list_v2_t< t_item > > | |
| Cpfc::traits_vtable | |
| Cpfc::vartoggle_t< T > | |
| Cpfc::winHandle | |
| ►Cplay_callback | |
| ►Cplay_callback_impl_base | Implementation helper |
| CCPlaybackStateDemo | |
| Cplayback_event_notify | Helper providing a simplified interface for receiving playback events, in case your code does not care about the kind of playback event that has occurred; useful typically for GUI/rendering code that just refreshes some control whenever a playback state change occurs |
| Cplayback_volume_notify | |
| Cplay_callback_static | Static (autoregistered) version of play_callback. Use play_callback_static_factory_t to register |
| ►Cplayable_location | |
| Cmake_playable_location | |
| Cplayable_location_impl | |
| Cplayable_location::comparator | |
| Cplayback_stream_capture_callback | |
| ►Cplaylist_callback | |
| ►Cplaylist_callback_impl_base | Playlist_callback implementation helper - registers itself on creation / unregisters on destruction. Must not be instantiated statically! |
| Cplaylist_position_reference_tracker | |
| Cplaylist_callback_static | |
| Cplaylist_callback::t_on_items_replaced_entry | |
| ►Cplaylist_callback_single | |
| ►Cplaylist_callback_single_impl_base | Playlist_callback_single implementation helper - registers itself on creation / unregisters on destruction. Must not be instantiated statically! |
| Cplaylist_lock_change_notify | |
| Cplaylist_callback_single_static | |
| ►Cplaylist_dataobject_desc | |
| ►Cplaylist_dataobject_desc_v2 | |
| Cplaylist_dataobject_desc_impl | |
| Cplaylist_dataobject_desc_impl::entry | |
| Cplaylist_manager::enum_items_callback | Callback interface for playlist enumeration methods |
| Cpreferences_state | |
| Cpfc::rcptr_t< bool > | |
| Cpfc::rcptr_t< file_info_const_impl > | |
| Cpfc::rcptr_t< pfc::string8 > | |
| Cpfc::rcptr_t< string_base const > | |
| Cpfc::rcptr_t< TWhat * > | |
| Cpfc::refcounted_object_ptr_t< t_node > | |
| Cpfc::refcounted_object_ptr_t< t_self > | |
| Cregisterclass_scope_delayed | |
| Creplaygain_info | Structure containing ReplayGain scan results from some playable object, also providing various helper methods to manipulate those results |
| CRIFF_chunk_desc | |
| Cseekabilizer_backbuffer | |
| CSelectObjectScope | |
| ►Cservice_base | Base class for all service classes.
Provides interfaces for reference counter and querying for different interfaces supported by the object.
|
| ►Cadvconfig_entry | Entrypoint class for adding items to Advanced Preferences page.
Implementations must derive from one of subclasses: advconfig_branch, advconfig_entry_checkbox, advconfig_entry_string.
Implementations are typically registered using static service_factory_single_t<myclass>, or using provided helper classes in case of standard implementations declared in this header |
| ►Cadvconfig_branch | Creates a new branch in Advanced Preferences.
Implementation: see advconfig_branch_impl / advconfig_branch_factory |
| ►Cadvconfig_branch_impl | Standard implementation of advconfig_branch.
Usage: no need to use this class directly - use advconfig_branch_factory instead |
| Cservice_impl_single_t< advconfig_branch_impl > | |
| ►Cadvconfig_entry_checkbox | Creates a checkbox/radiocheckbox entry in Advanced Preferences.
The difference between checkboxes and radiocheckboxes is different icon (obviously) and that checking a radiocheckbox unchecks all other radiocheckboxes in the same branch.
Implementation: see advconfig_entry_checkbox_impl / advconfig_checkbox_factory_t |
| ►Cadvconfig_entry_checkbox_v2 | |
| ►Cadvconfig_entry_checkbox_impl< p_is_radio, prefFlags > | Standard implementation of advconfig_entry_checkbox.
p_is_radio parameter controls whether we're implementing a checkbox or a radiocheckbox (see advconfig_entry_checkbox description for more details) |
| Cservice_impl_single_t< advconfig_entry_checkbox_impl< p_is_radio, prefFlags > > | |
| Cadvconfig_entry_enum | Not currently used, reserved for future use |
| ►Cadvconfig_entry_string | Creates a string/integer editbox entry in Advanced Preferences.
Implementation: see advconfig_entry_string_impl / advconfig_string_factory |
| ►Cadvconfig_entry_string_v2 | |
| ►Cadvconfig_entry_integer_impl | Special advconfig_entry_string implementation - implements integer entries. Use advconfig_integer_factory to register your own integer entries in Advanced Preferences instead of using this class directly |
| Cservice_impl_single_t< advconfig_entry_integer_impl > | |
| ►Cadvconfig_entry_string_impl | Standard advconfig_entry_string implementation. Use advconfig_string_factory to register your own string entries in Advanced Preferences instead of using this class directly |
| Cservice_impl_single_t< advconfig_entry_string_impl > | |
| ►Cadvconfig_entry_string_impl_MT | Special version if advconfig_entry_string_impl that allows the value to be retrieved from worker threads |
| Cservice_impl_single_t< advconfig_entry_string_impl_MT > | |
| ►Calbum_art_data | Common class for handling picture data.
Type of contained picture data is unknown and to be determined according to memory block contents by code parsing/rendering the picture. Commonly encountered types are: BMP, PNG, JPEG and GIF.
Implementation: use album_art_data_impl |
| Calbum_art_data_impl | Implements album_art_data |
| ►Calbum_art_editor | Entrypoint class for accessing album art editing functionality. Register your own implementation to allow album art editing on your media file format |
| Calbum_art_editor_impl_stdtags | Helper implementation of album_art_editor - edits album art from arbitrary file formats that comply with APEv2 tagging specification |
| ►Calbum_art_extractor | Entrypoint class for accessing album art extraction functionality. Register your own implementation to allow album art extraction from your media file format.
If you want to extract album art from a media file, it's recommended that you use album_art_manager API instead of calling album_art_extractor directly |
| Calbum_art_extractor_impl_stdtags | Helper implementation of album_art_extractor - reads album art from arbitrary file formats that comply with APEv2 tagging specification |
| ►Calbum_art_extractor_instance | Class encapsulating access to album art stored in a media file. Use album_art_extractor class obtain album_art_extractor_instance referring to specified media file |
| ►Calbum_art_editor_instance | Class encapsulating access to album art stored in a media file. Use album_art_editor class to obtain album_art_editor_instance referring to specified media file |
| Calbum_art_editor_instance_v2 | |
| Calbum_art_extractor_instance_fileref | Helper - a more advanced implementation of album_art_extractor_instance |
| Calbum_art_extractor_instance_simple | Helper - simple implementation of album_art_extractor_instance |
| Calbum_art_extractor_instance_v2 | Album_art_extractor_instance extension; lets the frontend query referenced file paths (eg. when using external album art) |
| Calbum_art_fallback | |
| Calbum_art_manager_config | |
| ►Calbum_art_manager_v2 | |
| Calbum_art_manager_v3 | |
| ►Calbum_art_path_list | Album art path list - see album_art_extractor_instance_v2 |
| Calbum_art_path_list_dummy | Album_art_path_list implementation helper |
| Calbum_art_path_list_impl | Album_art_path_list implementation helper |
| Capp_close_blocker | (DEPRECATED) This service is used to signal whether something is currently preventing main window from being closed and app from being shut down |
| Capp_close_blocking_task_manager | Entrypoint class for registering app_close_blocking_task instances. Introduced in 0.9.5.1.
Usage: static_api_ptr_t<app_close_blocking_task_manager>(). May fail if user runs pre-0.9.5.1. It's recommended that you use app_close_blocking_task_impl class instead of calling app_close_blocking_task_manager directly |
| Caudio_postprocessor | This class handles conversion of audio data (audio_chunk) to various linear PCM types, with optional dithering |
| ►Cautoplaylist_client | Main class controlling autoplaylist behaviors. Implemented by autoplaylist client in scenarios where simple query/sort strings are not enough (core provides a standard implementation for simple queries) |
| Cautoplaylist_client_v2 | |
| Cautoplaylist_client_factory | Class needed to re-instantiate autoplaylist_client after a restart. Not directly needed to set up an autoplaylist_client, but without it, your autoplaylist will be lost after a restart |
| ►Cautoplaylist_manager | Primary class for managing autoplaylists. Implemented by core, do not reimplement; instantiate using static_api_ptr_t<autoplaylist_manager> |
| Cautoplaylist_manager_v2 | |
| ►Cchapterizer | This service implements chapter list editing operations for various file formats, e.g. for MP4 chapters or CD images with embedded cuesheets. Used by converter "encode single file with chapters" feature |
| ►Ccue_parser::chapterizer_impl_t< t_input_impl > | |
| Cservice_impl_single_t< cue_parser::chapterizer_impl_t< t_input_impl > > | |
| Ccue_parser::chapterizer_impl_t< I > | |
| ►Ccommandline_handler | |
| Ccommandline_handler_metadb_handle | |
| ►Ccompletion_notify | Generic service for receiving notifications about async operation completion. Used by various other services |
| Ccompletion_notify_dummy | Implementation helper |
| ►Ccompletion_notify_orphanable | Implementation helper |
| Ccompletion_notify_impl< t_receiver > | Helper implementation. IMPLEMENTATION WARNING: If process being completed creates a window taking caller's window as parent, you must not destroy the parent window inside on_task_completion(). If you need to do so, use PostMessage() or main_thread_callback to delay the deletion |
| ►Ccomponent_installation_validator | |
| Ccomponent_installation_validator_filename | Simple implementation of component_installation_validator that makes sure that our component DLL has not been renamed around by idiot users |
| ►Ccomponentversion | Entrypoint interface for declaring component's version information. Instead of implementing this directly, use DECLARE_COMPONENT_VERSION() |
| Ccomponentversion_impl_copy | Implementation helper. You typically want to use DECLARE_COMPONENT_VERSION() instead |
| Ccomponentversion_impl_simple | Implementation helper. You typically want to use DECLARE_COMPONENT_VERSION() instead |
| ►Cconfig_io_callback | Implementing this interface lets you maintain your own configuration files rather than depending on the cfg_var system.
Note that you must not make assumptions about what happens first: config_io_callback::on_read(), initialization of cfg_var values or config_io_callback::on_read() in other components. Order of these things is undefined and will change with each run.
Use service_factory_single_t<myclass> to register your implementations. Do not call other people's implementations, core is responsible for doing that when appropriate |
| Cconfig_io_callback_v2 | |
| ►Cconfig_object | |
| Cconfig_object_fixed_const_impl_t< p_size > | |
| Cconfig_object_fixed_impl_t< p_size > | |
| Cconfig_object_impl | |
| ►Cconfig_object_notify | |
| Cconfig_object_notify_impl_simple | |
| Cconfig_object_notify_manager | |
| Cconsole_receiver | Interface receiving console output. Do not call directly; use console namespace functions instead |
| ►Ccontextmenu_group | |
| ►Ccontextmenu_group_impl | |
| Cservice_impl_single_t< contextmenu_group_impl > | |
| ►Ccontextmenu_group_popup | |
| ►Ccontextmenu_group_popup_impl | |
| Cservice_impl_single_t< contextmenu_group_popup_impl > | |
| Ccontextmenu_group_manager | |
| ►Ccontextmenu_item | |
| ►Ccontextmenu_item_v2 | |
| ►Ccontextmenu_item_simple | Contextmenu_item implementation helper for implementing non-dynamically-generated context menu items; derive from this instead of from contextmenu_item directly if your menu items are static |
| Cmyitem | |
| Ccontextmenu_manager | |
| ►Ccore_version_info | |
| Ccore_version_info_v2 | New (0.9.4.2) |
| Cdecode_postprocessor_entry | |
| Cdecode_postprocessor_instance | |
| ►Cdsp | Instance of a DSP.
Implementation: Derive from dsp_impl_base instead of deriving from dsp directly.
Instantiation: Use dsp_entry static helper methods to instantiate DSPs, or dsp_chain_config / dsp_manager to deal with entire DSP chains |
| Cdsp_v2 | Backwards-compatible extension to dsp interface, allows abortable operation. Introduced in 0.9.2 |
| Cdsp_config_callback | Callback class for getting notified about core playback DSP settings getting altered.
Register your implementations with static service_factory_single_t<myclass> g_myclass_factory; |
| Cdsp_config_manager | Core API for accessing core playback DSP settings as well as spawning DSP configuration dialogs.
Use static_api_ptr_t<dsp_config_manager>() to instantiate |
| ►Cdsp_entry | |
| ►Cdsp_entry_impl_nopreset_t< T > | |
| Cservice_impl_single_t< dsp_entry_impl_nopreset_t< T > > | |
| ►Cdsp_entry_v2 | |
| ►Cdsp_entry_v2_impl_t< T > | |
| Cservice_impl_single_t< dsp_entry_v2_impl_t< T > > | |
| ►Cresampler_entry | |
| ►Cdsp_entry_impl_t< T, resampler_entry > | |
| ►Cresampler_entry_impl_t< T > | |
| Cservice_impl_single_t< resampler_entry_impl_t< T > > | |
| ►Cevent_logger | |
| Cevent_logger_fallback | |
| ►Cevent_logger_recorder | |
| Cevent_logger_recorder_impl | |
| ►Cfile_info_filter | Implementing this class gives you direct control over which part of file_info gets altered during a tag update uperation. To be used with metadb_io_v2::update_info_async() |
| Cfile_info_filter_impl | Helper implementation of file_info_filter_impl |
| Cfile_operation_callback | Interface to notify component system about files being deleted or moved. Operates in app's main thread only |
| Cfile_operation_callback_dynamic_manager | New in 0.9.5 |
| Cfoobar2000_io::file | A class providing abstraction for an open file object, with reading/writing/seeking methods. See also: stream_reader, stream_writer (which it inherits read/write methods from).
Error handling: all methods may throw exception_io or one of derivatives on failure; exception_aborted when abort_callback is signaled |
| ►Cfoobar2000_io::filesystem | Entrypoint service for all filesystem operations.
Implementation: standard implementations for local filesystem etc are provided by core.
Instantiation: use static helper functions rather than calling filesystem interface methods directly, e.g. filesystem::g_open() to open a file |
| ►Cfoobar2000_io::archive | Interface for archive reader services. When implementing, derive from archive_impl rather than from deriving from archive directly |
| Cfoobar2000_io::archive_impl | Root class for archive implementations. Derive from this instead of from archive directly |
| Cgenrand_service | PRNG service. Implemented by the core, do not reimplement. Use g_create() helper function to instantiate |
| Chasher_md5 | |
| Chttp_client | |
| Chttp_reply | Implemented by file object returned by http_request::run methods. Allows you to retrieve various additional information returned by the server.
Warning: reply status may change when seeking on the file object since seek operations often require a new HTTP request to be fired |
| ►Chttp_request | |
| Chttp_request_post | |
| ►Cicon_remapping | New in 0.9.5; allows your file format to use another icon than <extension>.ico when registering the file type with Windows shell.
Implementation: use icon_remapping_impl, or simply: static service_factory_single_t<icon_remapping_impl> myicon("ext","iconname.ico"); |
| Cicon_remapping_impl | Standard implementation of icon_remapping |
| Cicon_remapping_wildcard_impl | |
| ►Cinfo_lookup_handler | Service used to access various external (online) track info lookup services, such as freedb, to update file tags with info retrieved from those services |
| Cinfo_lookup_handler_v2 | |
| Cinit_stage_callback | |
| ►Cinitquit | Basic callback startup/shutdown callback, on_init is called after the main window has been created, on_quit is called before the main window is destroyed.
To register: static initquit_factory_t<myclass> myclass_factory;
Note that you should be careful with calling other components during on_init/on_quit or
initializing services that are possibly used by other components by on_init/on_quit -
initialization order of components is undefined. If some other service that you publish is not properly functional before you receive an on_init() call,
someone else might call this service before >your< on_init is invoked |
| Cmyinitquit | |
| ►Cinput_entry | |
| Cinput_entry_impl_t< I, t_flags, t_decoder, t_inforeader, t_infowriter > | Helper; standard input_entry implementation. Do not instantiate this directly, use input_factory_t or one of other input_*_factory_t helpers instead |
| ►Cinput_entry_impl_t< cue_parser::input_wrapper_cue_t< t_input_impl >, t_flags, input_decoder_v2, input_info_reader, input_info_writer > | |
| Cservice_impl_single_t< input_entry_impl_t< cue_parser::input_wrapper_cue_t< t_input_impl >, t_flags, input_decoder_v2, input_info_reader, input_info_writer > > | |
| ►Cinput_entry_impl_t< input_wrapper_singletrack_t< T >, 0 > | |
| Cservice_impl_single_t< input_entry_impl_t< input_wrapper_singletrack_t< T >, 0 > > | |
| ►Cinput_entry_impl_t< input_wrapper_singletrack_t< T >, t_flags, t_decoder, t_inforeader, t_infowriter > | |
| Cservice_impl_single_t< input_entry_impl_t< input_wrapper_singletrack_t< T >, t_flags, t_decoder, t_inforeader, t_infowriter > > | |
| ►Cinput_entry_impl_t< T, 0 > | |
| Cservice_impl_single_t< input_entry_impl_t< T, 0 > > | |
| ►Cinput_entry_impl_t< T, t_flags, t_decoder, t_inforeader, t_infowriter > | |
| Cservice_impl_single_t< input_entry_impl_t< T, t_flags, t_decoder, t_inforeader, t_infowriter > > | |
| ►Cinput_file_type | Entrypoint interface for registering media file types that can be opened through "open file" dialogs or associated with foobar2000 application in Windows shell.
Instead of implementing this directly, use DECLARE_FILE_TYPE() / DECLARE_FILE_TYPE_EX() macros |
| ►Cinput_file_type_v2 | Extended interface for registering media file types that can be associated with foobar2000 application in Windows shell.
Instead of implementing this directly, use DECLARE_FILE_TYPE() / DECLARE_FILE_TYPE_EX() macros |
| Cinput_file_type_v2_impl | |
| ►Cservice_impl_single_t< input_file_type > | |
| ►Cinput_file_type_impl | Implementation helper |
| ►Cservice_impl_single_t< input_file_type_impl > | |
| ►Cservice_factory_single_transparent_t< input_file_type_impl > | |
| Cinput_file_type_factory | Implementation helper. Usage: static input_file_type_factory mytype("blah type","*.bla;*.meh",true); |
| ►Cinput_info_reader | Class providing interface for retrieval of information (metadata, duration, replaygain, other tech infos) from files. Also see: file_info.
Instantiating: see input_entry.
Implementing: see input_impl |
| ►Cinput_decoder | Class providing interface for retrieval of PCM audio data from files.
Instantiating: see input_entry.
Implementing: see input_impl |
| ►Cinput_decoder_v2 | |
| Cinput_decoder_v3 | |
| ►Cinput_info_writer | Class providing interface for writing metadata and replaygain info to files. Also see: file_info.
Instantiating: see input_entry.
Implementing: see input_impl |
| Cinput_info_writer_v2 | |
| Cinput_protocol_type | Service for registering protocol types that can be associated with foobar2000 |
| ►Ckeyboard_shortcut_manager | |
| Ckeyboard_shortcut_manager_v2 | New in 0.9.5 |
| Clibrary_callback | Callback service receiving notifications about Media Library content changes. Methods called only from main thread.
Use library_callback_factory_t template to register |
| Clibrary_file_move_manager | |
| Clibrary_file_move_notify | |
| Clibrary_file_move_scope | |
| ►Clibrary_manager | |
| ►Clibrary_manager_v2 | |
| Clibrary_manager_v3 | |
| Clibrary_meta_autocomplete | |
| Clibrary_search_ui | |
| Clibrary_viewer | Implement this service to appear on "library viewers" list in Media Library preferences page.
Use library_viewer_factory_t to register |
| Clink_resolver | Interface for resolving different sorts of link files. Utilized by mechanisms that convert filesystem path into list of playable locations. For security reasons, link may only point to playable object path, not to a playlist or another link |
| ►Cmain_thread_callback | Callback object class for main_thread_callback_manager service |
| C_callInMainThreadSvc_t< service_t, param_t > | |
| CcallInMainThreadHelper::entry< host_t, arg_t > | |
| CcallInMainThreadHelper::entryFunc | |
| CcallInMainThreadHelper::entryVoid< host_t > | |
| CCF::_inMainThread< obj_t, arg_t > | |
| Cmain_thread_callback_manager | |
| ►Cmainmenu_commands | |
| Cmainmenu_commands_sample | |
| Cmainmenu_commands_v2 | |
| ►Cmainmenu_group | |
| Cmainmenu_group_impl | |
| ►Cmainmenu_group_popup | |
| Cmainmenu_group_popup_impl | |
| Cmainmenu_manager | |
| ►Cmainmenu_node | |
| Cmainmenu_node_command | |
| Cmainmenu_node_group | |
| Cmainmenu_node_separator | |
| Cmenu_item_resolver | New in 0.9.5.1. Static methods safe to use in prior versions as it will use slow fallback mode when the service isn't present.
Functionality provided by menu_item_resolver methods isn't much different from just walking all registered contextmenu_item / mainmenu_commands implementations to find the command we want, but it uses a hint map to locate the service we're looking for without walking all of them which may be significantly faster in certain scenarios |
| ►Cmessage_loop | |
| Cmessage_loop_v2 | |
| Cmetadb | Entrypoint service for metadb_handle related operations.
Implemented only by core, do not reimplement.
Use static_api_ptr_t template to access it, e.g. static_api_ptr_t<metadb>()->handle_create(myhandle,mylocation); |
| Cmetadb_display_field_provider | |
| Cmetadb_handle | A metadb_handle object represents interface to reference-counted file_info cache entry for the specified location.
To obtain a metadb_handle to specific location, use metadb::handle_create(). To obtain a list of metadb_handle objects corresponding to specific path (directory, playlist, multitrack file, etc), use relevant playlist_incoming_item_filter methods (recommended), or call playlist_loader methods directly.
A metadb_handle is also the most efficient way of passing playable object locations around because it provides fast access to both location and infos, and is reference counted so duplicating it is as fast as possible.
To retrieve a path of a file from a metadb_handle, use metadb_handle::get_path() function. Note that metadb_handle is NOT just file path, some formats support multiple subsongs per physical file, which are signaled using subsong indexes |
| ►Cmetadb_hint_list | Advanced interface for passing infos read from files to metadb backend. Use metadb_io_v2::create_hint_list() to instantiate |
| ►Cmetadb_hint_list_v2 | |
| Cmetadb_hint_list_v3 | |
| Cmetadb_index_client | |
| Cmetadb_index_manager | |
| Cmetadb_info_container | |
| ►Cmetadb_io | API for tag read/write operations. Legal to call from main thread only, except for hint_multi_async() / hint_async() / hint_reader().
Implemented only by core, do not reimplement.
Use static_api_ptr_t template to access metadb_io methods.
WARNING: Methods that perform file access (tag reads/writes) run a modal message loop. They SHOULD NOT be called from global callbacks and such |
| ►Cmetadb_io_v2 | New in 0.9.3. Extends metadb_io functionality with nonblocking versions of tag read/write functions, and some other utility features |
| Cmetadb_io_v3 | New (0.9.5) |
| Cmetadb_io_callback | Callback service receiving notifications about metadb contents changes |
| Cmetadb_io_edit_callback | |
| Cmodeless_dialog_manager | Service for plugging your nonmodal dialog windows into main app loop to receive IsDialogMessage()-translated messages.
Note that all methods are valid from main app thread only.
Usage: static_api_ptr_t<modeless_dialog_manager> or modeless_dialog_manager::g_add / modeless_dialog_manager::g_remove |
| ►Cole_interaction | |
| Cole_interaction_v2 | |
| ►Coutput | |
| ►Coutput_v2 | |
| Coutput_impl | |
| ►Coutput_entry | |
| ►Coutput_entry_impl_t< T > | |
| Cservice_impl_single_t< output_entry_impl_t< T > > | |
| Coutput_entry_v2 | |
| Coutput_manager | |
| ►Cpacket_decoder | Provides interface to decode various audio data types to PCM. Use packet_decoder_factory_t template to register |
| Cpacket_decoder_streamparse | |
| ►Cpacket_decoder_entry | |
| ►Cpacket_decoder_entry_impl_t< T > | |
| Cservice_impl_single_t< packet_decoder_entry_impl_t< T > > | |
| Cplay_callback_manager | Standard API (always present); manages registrations of dynamic play_callbacks. Usage: use static_api_ptr_t<play_callback_manager>. Do not reimplement |
| Cplay_callback_static | Static (autoregistered) version of play_callback. Use play_callback_static_factory_t to register |
| ►Cplayback_control | Provides control for various playback-related operations. All methods provided by this interface work from main app thread only. Calling from another thread will do nothing or trigger an exception. If you need to trigger one of playback_control methods from another thread, see main_thread_callback. Do not call playback_control methods from inside any kind of global callback (e.g. playlist callback), otherwise race conditions may occur. Use static_api_ptr_t to instantiate. See static_api_ptr_t documentation for more info |
| ►Cplayback_control_v2 | |
| Cplayback_control_v3 | |
| Cplayback_queue_callback | |
| Cplayback_statistics_collector | Gets notified about tracks being played. Notification occurs when at least 60s of the track has been played, or the track has reached its end after at least 1/3 of it has been played through. Use playback_statistics_collector_factory_t to register |
| Cplayback_stream_capture | |
| Cplaylist_callback_single_static | |
| Cplaylist_callback_static | |
| ►Cplaylist_incoming_item_filter | |
| ►Cplaylist_incoming_item_filter_v2 | |
| Cplaylist_incoming_item_filter_v3 | |
| Cplaylist_loader | Service handling playlist file operations. There are multiple implementations handling different playlist formats; you can add new implementations to allow new custom playlist file formats to be read or written.
Also provides static helper functions for turning a filesystem path into a list of playable item locations.
Note that you should typically call playlist_incoming_item_filter methods instead of calling playlist_loader methods directly to get a list of playable items from a specified path; this way you get a core-implemented threading and abortable dialog displaying progress.
To register your own implementation, use playlist_loader_factory_t template.
To call existing implementations, use static helper methods of playlist_loader class |
| ►Cplaylist_loader_callback | Callback interface receiving item locations from playlist loader.
Typically, you call one of standard services such as playlist_incoming_item_filter instead of implementing this interface and calling playlist_loader methods directly |
| Cplaylist_loader_callback_v2 | |
| Cplaylist_lock | This interface allows filtering of playlist modification operations.
Implemented by components "locking" playlists; use playlist_manager::playlist_lock_install() etc to takeover specific playlist with your instance of playlist_lock |
| ►Cplaylist_manager | This service provides methods for all sorts of playlist interaction.
All playlist_manager methods are valid only from main app thread.
Usage: static_api_ptr_t<playlist_manager> |
| ►Cplaylist_manager_v2 | Extension of the playlist_manager service that manages playlist properties. Playlist properties come in two flavors: persistent and runtime. Persistent properties are blocks of binary that that will be preserved when the application is exited and restarted. Runtime properties are service pointers that will be lost when the application exits |
| ►Cplaylist_manager_v3 | |
| Cplaylist_manager_v4 | |
| Cpopup_message | This interface allows you to show generic nonmodal noninteractive dialog with a text message. This should be used instead of MessageBox where possible.
Usage: use popup_message::g_show / popup_message::g_show_ex static helpers, or static_api_ptr_t<popup_message>.
Note that all strings are UTF-8 |
| Cpopup_message_v2 | |
| ►Cpreferences_branch | Creates a preferences branch - an empty page that only serves as a parent for other pages and is hidden when no child pages exist. Instead of implementing this, simply use preferences_branch_factory class to declare a preferences branch with specified parameters |
| ►Cpreferences_branch_v2 | |
| Cpreferences_branch_impl | |
| ►Cpreferences_page | Implementing this service will generate a page in preferences dialog. Use preferences_page_factory_t template to register.
In 1.0 and newer you should always derive from preferences_page_v3 rather than from preferences_page directly |
| ►Cpreferences_page_v2 | |
| ►Cpreferences_page_v3 | |
| Cpreferences_page_impl< TDialog > | |
| ►Cpreferences_page_impl< CMyPreferences > | |
| Cpreferences_page_myimpl | |
| Cpreferences_page_callback | |
| ►Cpreferences_page_instance | |
| CCMyPreferences | |
| Cprocess_locations_notify | For use with playlist_incoming_item_filter_v2::process_locations_async() |
| Cprogress_meter | Entrypoint interface for instantiating progress_meter_instance objects |
| Cprogress_meter_instance | Interface for setting current operation progress state to be visible on Windows 7 taskbar. Use static_api_ptr_t<progress_meter>()->acquire() to instantiate |
| Creplaygain_manager | Core service providing methods to retrieve/alter playback ReplayGain settings, as well as use ReplayGain configuration dialog |
| Creplaygain_result | Container of ReplayGain scan results from one or more tracks |
| Creplaygain_scanner | Instance of a ReplayGain scanner.
Use static_api_ptr_t<replaygain_scanner_entry>()->instantiate() to create a replaygain_scanner object; see replaygain_scanner_entry for more info.
Typical use: call process_chunk() with each chunk read from your track, call finalize() to obtain results for this track and reset replaygain_scanner's state for scanning another track; to obtain album gain/peak values, merge results (replaygain_result::merge) from all tracks.
|
| Creplaygain_scanner_entry | Entrypoint class for instantiating replaygain_scanner objects. Use static_api_ptr_t<replaygain_scanner_entry>()->instantiate() to create replaygain_scanner instances.
This service is OPTIONAL; it's available from foobar2000 0.9.5.3 up but only if the ReplayGain Scanner component is installed.
It is recommended that you use replaygain_scanner like this: try { myInstance = static_api_ptr_t<replaygain_scanner_entry>()->instantiate(); } catch(exception_service_not_found) { /* too old foobar2000 version or no foo_rgscan installed - complain/fail/etc */ } |
| ►Csearch_filter | Instance of a search filter object. New in 0.9.5.
This object contains a preprocessed search query; used to perform filtering similar to Media Library Search or Album List's "filter" box.
Use search_filter_manager API to instantiate search_filter objects |
| ►Csearch_filter_v2 | New in 0.9.5.3. You can obtain a search_filter_v2 pointer by using service_query() on a search_filter pointer, or from search_filter_manager_v2::create_ex() |
| Csearch_filter_v3 | New in 0.9.5.4. You can obtain a search_filter_v2 pointer by using service_query() on a search_filter/search_filter_v2 pointer |
| ►Csearch_filter_manager | Entrypoint class to instantiate search_filter objects. New in 0.9.5 |
| Csearch_filter_manager_v2 | New in 0.9.5.3 |
| Csystem_time_keeper | |
| Ctag_processor_album_art_utils | Helper API for extracting album art from APEv2 tags - introduced in 0.9.5 |
| Ctag_processor_id3v2 | For internal use - call tag_processor namespace methods instead |
| Ctag_processor_trailing | For internal use - call tag_processor namespace methods instead |
| Cthreaded_process | The threaded_process API allows you to easily put timeconsuming tasks in worker threads, with progress dialog giving nice feedback to the user.
Thanks to this API you can perform such tasks with no user interface related programming at all |
| ►Cthreaded_process_callback | Callback class for the threaded_process API. You must implement this to create your own threaded_process client |
| Ccalculate_peak_process | |
| Cthreaded_process_callback_redir< TTarget > | Helper - forward threaded_process_callback calls to a service object that for whatever reason cannot publish threaded_process_callback API by itself |
| Ctitleformat_common_methods | |
| Ctitleformat_compiler | Standard service for instantiating titleformat_object. Implemented by the core; do not reimplement. To instantiate, use static_api_ptr_t<titleformat_compiler> |
| Ctitleformat_object | Represents precompiled executable title-formatting script. Use titleformat_compiler to instantiate; do not reimplement |
| ►Ctrack_property_provider | Service for adding custom entries in "Properties" tab of the properties dialog |
| ►Ctrack_property_provider_v2 | |
| Ctrack_property_provider_v3 | |
| Cui_control | Serivce providing various UI-related commands. Implemented by core; do not reimplement. Instantiation: use static_api_ptr_t<ui_control> |
| Cui_drop_item_callback | Service called from the UI when some object is dropped into the UI. Usable for modifying drag&drop behaviors such as adding custom handlers for object types other than supported media files.
Implement where needed; use ui_drop_item_callback_factory_t<> template to register, e.g. static ui_drop_item_callback_factory_t<myclass> g_myclass_factory |
| ►Cui_edit_context | |
| Cui_edit_context_playlist | |
| Cui_edit_context_manager | |
| ►Cui_element | Entrypoint interface for each UI element implementation |
| ►Cui_element_v2 | Extended interface for a UI element implementation |
| ►Cui_element_impl< ImplementBumpableElem< CMyElemWindow >, ui_element_v2 > | |
| ►Cui_element_impl_withpopup< CMyElemWindow > | |
| Cui_element_myimpl | |
| Cui_element_children_enumerator | Interface to enumerate and possibly alter children of a container element. Obtained from ui_element::enumerate_children() |
| ►Cui_element_common_methods | For use with static_api_ptr_t<> |
| Cui_element_common_methods_v2 | For use with static_api_ptr_t<> |
| Cui_element_config | Configuration of a UI element |
| ►Cui_element_instance | Instance of a UI element |
| CCMyElemWindow | |
| ►Cui_element_instance_callback | Callback class passed by a UI element host to a UI element instance, allowing each UI element instance to communicate with its host.
Each ui_element_instance_callback implementation must also implement ui_element_instance_callback_v2 |
| ►Cui_element_instance_callback_v2 | |
| ►Cui_element_instance_callback_v3 | |
| Cui_element_instance_callback_impl< t_receiver > | Ui_element_instance_callback implementation helper |
| ►Cui_element_popup_host | |
| Cui_element_popup_host_v2 | |
| Cui_element_popup_host_callback | |
| Cui_element_typable_window_manager | |
| Cui_selection_holder | Write interface and reference counter for the shared selection. The ui_selection_manager stores the selected items as a list. The ui_selection_holder service allows components to modify this list. It also serves as a reference count: the ui_selection_manager clears the stored selection when no component holds a reference to a ui_selection_holder |
| ►Cui_selection_manager | |
| Cui_selection_manager_v2 | |
| Cui_status_text_override | Interface class allowing you to override UI statusbar text. There may be multiple callers trying to override statusbar text; backend decides which one succeeds so you will not always get what you want. Statusbar text override is automatically cancelled when the object is released.
Use ui_control::override_status_text_create() to instantiate. Implemented by core. Do not reimplement |
| Cunpacker | Service providing "unpacker" functionality - processes "packed" file (such as a zip file containing a single media file inside) to allow its contents to be accessed transparently.
To access existing unpacker implementations, use unpacker::g_open helper function.
To register your own implementation, use unpacker_factory_t template |
| Cuser_interface | Entrypoint service for user interface modules. Implement when registering an UI module. Do not call existing implementations; only core enumerates / dispatches calls. To control UI behaviors from other components, use ui_control API.
Use user_interface_factory_t<> to register, e.g static user_interface_factory_t<myclass> g_myclass_factory; |
| Cvisualisation_manager | Entrypoint service for visualisation processing; use this to create visualisation_stream objects that can be used to retrieve properties of currently played audio.
Implemented by core; do not reimplement.
Use static_api_ptr_t to access it, e.g. static_api_ptr_t<visualisation_manager>()->create_stream(mystream,0); |
| ►Cvisualisation_stream | This class provides abstraction for retrieving visualisation data. Instances of visualisation_stream being created/released serve as an indication for visualisation backend to process currently played audio data or shut down when there are no visualisation clients active.
Use visualisation_manager::create_stream to instantiate |
| ►Cvisualisation_stream_v2 | New in 0.9.5 |
| Cvisualisation_stream_v3 | New in 0.9.5.2 |
| Cvolume_control | |
| Cservice_by_guid_data< what > | |
| Cservice_class_helper_t< T > | |
| Cservice_class_helper_t< t_interface > | |
| Cservice_enum_t< t_interface > | |
| ►Cservice_factory_base | |
| Cservice_factory_base_t< B > | |
| ►Cservice_factory_base_t< _config_object_fixed_impl_switch< p_size, isConst >::type::t_interface_entrypoint > | |
| Cservice_factory_single_transparent_t< _config_object_fixed_impl_switch< p_size, isConst >::type > | |
| ►Cservice_factory_base_t< advconfig_branch_impl::t_interface_entrypoint > | |
| ►Cservice_factory_single_t< advconfig_branch_impl > | |
| Cadvconfig_branch_factory | Service factory helper around standard advconfig_branch implementation. Use this class to register your own Advanced Preferences branches.
Usage: static advconfig_branch_factory mybranch(name, branchID, parentBranchID, priority); |
| ►Cservice_factory_base_t< advconfig_entry_checkbox_impl< p_is_radio, prefFlags >::t_interface_entrypoint > | |
| ►Cservice_factory_single_t< advconfig_entry_checkbox_impl< p_is_radio, prefFlags > > | |
| Cadvconfig_checkbox_factory_t< p_is_radio, prefFlags > | Service factory helper around standard advconfig_entry_checkbox implementation. Use this class to register your own Advanced Preferences checkbox/radiocheckbox entries.
Usage: static advconfig_entry_checkbox<isRadioBox> mybox(name, itemID, parentID, priority, initialstate); |
| ►Cservice_factory_base_t< advconfig_entry_integer_impl::t_interface_entrypoint > | |
| ►Cservice_factory_single_t< advconfig_entry_integer_impl > | |
| Cadvconfig_integer_factory | Service factory helper around integer-specialized advconfig_entry_string implementation. Use this class to register your own integer entries in Advanced Preferences.
Usage: static advconfig_integer_factory myint(name, itemID, parentID, priority, initialValue, minValue, maxValue); |
| ►Cservice_factory_base_t< advconfig_entry_string_impl::t_interface_entrypoint > | |
| ►Cservice_factory_single_t< advconfig_entry_string_impl > | |
| Cadvconfig_string_factory | Service factory helper around standard advconfig_entry_string implementation. Use this class to register your own string entries in Advanced Preferences.
Usage: static advconfig_string_factory mystring(name, itemID, branchID, priority, initialValue); |
| ►Cservice_factory_base_t< advconfig_entry_string_impl_MT::t_interface_entrypoint > | |
| ►Cservice_factory_single_t< advconfig_entry_string_impl_MT > | |
| Cadvconfig_string_factory_MT | Special version if advconfig_string_factory that allows the value to be retrieved from worker threads |
| ►Cservice_factory_base_t< contextmenu_group_impl::t_interface_entrypoint > | |
| ►Cservice_factory_single_t< contextmenu_group_impl > | |
| Ccontextmenu_group_factory | |
| ►Cservice_factory_base_t< contextmenu_group_popup_impl::t_interface_entrypoint > | |
| ►Cservice_factory_single_t< contextmenu_group_popup_impl > | |
| Ccontextmenu_group_popup_factory | |
| ►Cservice_factory_base_t< cue_parser::chapterizer_impl_t< t_input_impl >::t_interface_entrypoint > | |
| Cservice_factory_single_t< cue_parser::chapterizer_impl_t< t_input_impl > > | |
| ►Cservice_factory_base_t< dsp_entry_impl_nopreset_t< T >::t_interface_entrypoint > | |
| ►Cservice_factory_single_t< dsp_entry_impl_nopreset_t< T > > | |
| Cdsp_factory_nopreset_t< T > | |
| ►Cservice_factory_base_t< dsp_entry_v2_impl_t< T >::t_interface_entrypoint > | |
| ►Cservice_factory_single_t< dsp_entry_v2_impl_t< T > > | |
| Cdsp_factory_t< T > | |
| ►Cservice_factory_base_t< input_entry_impl_t< cue_parser::input_wrapper_cue_t< t_input_impl >, t_flags, input_decoder_v2, input_info_reader, input_info_writer >::t_interface_entrypoint > | |
| ►Cservice_factory_single_t< input_entry_impl_t< cue_parser::input_wrapper_cue_t< t_input_impl >, t_flags, input_decoder_v2, input_info_reader, input_info_writer > > | |
| Cinput_factory_ex_t< cue_parser::input_wrapper_cue_t< t_input_impl >, t_flags, input_decoder_v2 > | |
| ►Cservice_factory_base_t< input_entry_impl_t< input_wrapper_singletrack_t< T >, 0 >::t_interface_entrypoint > | |
| ►Cservice_factory_single_t< input_entry_impl_t< input_wrapper_singletrack_t< T >, 0 > > | |
| Cinput_singletrack_factory_t< T > | Non-multitrack-enabled input factory (helper) - hides multitrack management functions from input implementation; use this for inputs that handle file types where each physical file can contain only one user-visible playable track. For reference of functions that must be supported by registered class, see input_singletrack_impl.
Usage: static input_singletrack_factory_t<myinputclass> g_myinputclass_factory;
Note that input classes can't be registered through service_factory_t template directly.template<class T> |
| ►Cservice_factory_base_t< input_entry_impl_t< input_wrapper_singletrack_t< T >, t_flags, t_decoder, t_inforeader, t_infowriter >::t_interface_entrypoint > | |
| ►Cservice_factory_single_t< input_entry_impl_t< input_wrapper_singletrack_t< T >, t_flags, t_decoder, t_inforeader, t_infowriter > > | |
| Cinput_singletrack_factory_ex_t< T, t_flags, t_decoder, t_inforeader, t_infowriter > | Extended version of input_singletrack_factory_t, with non-default flags and supported interfaces. See: input_singletrack_factory_t, input_entry::get_flags() |
| ►Cservice_factory_base_t< input_entry_impl_t< T, 0 >::t_interface_entrypoint > | |
| ►Cservice_factory_single_t< input_entry_impl_t< T, 0 > > | |
| Cinput_factory_t< T > | Stardard input factory. For reference of functions that must be supported by registered class, see input_impl.
Usage: static input_factory_t<myinputclass> g_myinputclass_factory;
Note that input classes can't be registered through service_factory_t template directly |
| ►Cservice_factory_base_t< input_entry_impl_t< T, t_flags, t_decoder, t_inforeader, t_infowriter >::t_interface_entrypoint > | |
| ►Cservice_factory_single_t< input_entry_impl_t< T, t_flags, t_decoder, t_inforeader, t_infowriter > > | |
| Cinput_factory_ex_t< T, t_flags, t_decoder, t_inforeader, t_infowriter > | Extended version of input_factory_t, with non-default flags and supported interfaces. See: input_factory_t, input_entry::get_flags() |
| ►Cservice_factory_base_t< input_file_type_impl::t_interface_entrypoint > | |
| Cservice_factory_single_transparent_t< input_file_type_impl > | |
| ►Cservice_factory_base_t< output_entry_impl_t< T >::t_interface_entrypoint > | |
| ►Cservice_factory_single_t< output_entry_impl_t< T > > | |
| Coutput_factory_t< T > | Use this to register your output implementation |
| ►Cservice_factory_base_t< packet_decoder_entry_impl_t< T >::t_interface_entrypoint > | |
| ►Cservice_factory_single_t< packet_decoder_entry_impl_t< T > > | |
| Cpacket_decoder_factory_t< T > | |
| ►Cservice_factory_base_t< resampler_entry_impl_t< T >::t_interface_entrypoint > | |
| ►Cservice_factory_single_t< resampler_entry_impl_t< T > > | |
| Cresampler_factory_t< T > | |
| ►Cservice_factory_base_t< T::t_interface_entrypoint > | |
| Cservice_factory_single_ref_t< T > | |
| ►Cservice_factory_single_t< T > | |
| Ccontextmenu_item_factory_t< T > | Helper |
| Cfoobar2000_io::archive_factory_t< T > | |
| Cinitquit_factory_t< T > | |
| Clibrary_callback_factory_t< T > | |
| Clibrary_viewer_factory_t< T > | |
| Cmainmenu_commands_factory_t< T > | |
| Cmainmenu_group_factory | |
| Cmainmenu_group_popup_factory | |
| Cplay_callback_static_factory_t< T > | |
| Cplayback_statistics_collector_factory_t< T > | |
| Cpreferences_branch_factory | Instantiating this class declares a preferences branch with specified parameters.
Usage: static preferences_branch_factory g_mybranch(mybranchguid,parentbranchguid,"name of my preferences branch goes here"); |
| Cpreferences_page_factory_t< T > | |
| Ctrack_property_provider_factory_t< T > | |
| Cui_drop_item_callback_factory_t< T > | |
| Cuser_interface_factory< T > | |
| ►Cservice_factory_single_transparent_t< T > | |
| Ccomponentversion_impl_copy_factory | |
| Ccomponentversion_impl_simple_factory | |
| Cconfig_object_string_factory | |
| ►Cservice_factory_t< T > | |
| Ccommandline_handler_factory_t< T > | |
| ►Cservice_factory_base_t< t_myclass::t_interface_entrypoint > | |
| ►Cservice_factory_single_t< t_myclass > | |
| Cplaylist_loader_factory_t< t_myclass > | |
| Cunpacker_factory_t< t_myclass > | |
| Cservice_factory_traits< B > | |
| Cservice_instance_array_t< T > | Helper; simulates array with instance of each available implementation of given service class |
| ►Cservice_ptr_base_t< T > | |
| Cservice_nnptr_t< T > | Autopointer class to be used with all services. Manages reference counter calls behind-the-scenes.
This assumes that the pointers are valid all the time (can't point to null). Mainly intended to be used for scenarios where null pointers are not valid and relevant code should crash ASAP if somebody passes invalid pointers around.
You want to use service_ptr_t<> rather than service_nnptr_t<> most of the time |
| Cservice_ptr_t< T > | Autopointer class to be used with all services. Manages reference counter calls behind-the-scenes |
| ►Cservice_ptr_base_t< audio_postprocessor > | |
| Cservice_ptr_t< audio_postprocessor > | |
| ►Cservice_ptr_base_t< completion_notify > | |
| Cservice_ptr_t< completion_notify > | |
| ►Cservice_ptr_base_t< completion_notify_orphanable > | |
| Cservice_ptr_t< completion_notify_orphanable > | |
| ►Cservice_ptr_base_t< config_object > | |
| Cservice_ptr_t< config_object > | |
| ►Cservice_ptr_base_t< contextmenu_item_simple > | |
| Cservice_ptr_t< contextmenu_item_simple > | |
| ►Cservice_ptr_base_t< dsp > | |
| Cservice_ptr_t< dsp > | |
| ►Cservice_ptr_base_t< file > | |
| Cservice_ptr_t< file > | |
| ►Cservice_ptr_base_t< input_decoder > | |
| Cservice_ptr_t< input_decoder > | |
| ►Cservice_ptr_base_t< input_info_reader > | |
| Cservice_ptr_t< input_info_reader > | |
| ►Cservice_ptr_base_t< metadb_handle > | |
| Cservice_ptr_t< metadb_handle > | |
| ►Cservice_ptr_base_t< service_t > | |
| Cservice_ptr_t< service_t > | |
| ►Cservice_ptr_base_t< titleformat_object > | |
| Cservice_ptr_t< titleformat_object > | |
| ►Cservice_ptr_base_t< TTarget > | |
| Cservice_ptr_t< TTarget > | |
| ►Cservice_ptr_base_t< ui_element_instance > | |
| Cservice_ptr_t< ui_element_instance > | |
| ►Cservice_ptr_base_t< ui_element_instance_callback_impl > | |
| Cservice_ptr_t< ui_element_instance_callback_impl > | |
| ►Cservice_ptr_base_t< ui_status_text_override > | |
| Cservice_ptr_t< ui_status_text_override > | |
| CSetTextColorScope | |
| ►Csse_control | |
| Csse_control_flushdenormal | |
| Cstandard_commands | |
| Cstandard_config_objects | |
| Cstatic_api_ptr_t< t_interface > | Helper template used to easily access core services.
Usage: static_api_ptr_t<myclass> api; api->dosomething(); Can be used at any point of code, WITH EXCEPTION of static objects that are initialized during the DLL loading process before the service system is initialized; such as static static_api_ptr_t objects or having static_api_ptr_t instances as members of statically created objects. Throws exception_service_not_found if service could not be reached (which can be ignored for core APIs that are always present unless there is some kind of bug in the code) |
| Cstatic_api_ptr_t< hasher_md5 > | |
| Cstatic_api_ptr_t< playback_control > | |
| Cstatic_api_ptr_t< titleformat_common_methods > | |
| ►Cstd::exception | STL class |
| Cexception_com | |
| Cexception_win32 | |
| Cpfc::exception_nix | |
| ►Cstream_reader | |
| Cdsp_preset_reader | |
| CProcessUtils::PipeIO | |
| CProcessUtils::SubProcess | |
| Cstream_reader_buffered | |
| Cstream_reader_chunk | |
| Cstream_reader_dummy | |
| Cstream_reader_limited_ref | |
| Cstream_reader_memblock_ref | |
| Cstream_reader_formatter< isBigEndian > | |
| ►Cstream_reader_formatter< BE > | |
| ►Cstream_reader_formatter_simple_ref< BE > | |
| Cstream_reader_formatter_simple< BE > | |
| ►Cstream_reader_formatter<> | |
| Cdsp_preset_parser | Helper |
| Cui_element_config_parser | Helper |
| ►Cstream_writer | |
| Cdsp_preset_writer | |
| CProcessUtils::PipeIO | |
| CProcessUtils::SubProcess | |
| Cstream_writer_buffer_append_ref_t< t_storage > | |
| Cstream_writer_buffer_simple | |
| Cstream_writer_buffered | |
| Cstream_writer_chunk | |
| Cstream_writer_chunk_dwordheader | |
| Cstream_writer_hasher_md5 | |
| ►Cstream_writer_formatter< isBigEndian > | |
| Cstream_formatter_hasher_md5< isBigEndian > | |
| ►Cstream_writer_formatter< BE > | |
| Cstream_writer_formatter_simple< BE > | |
| ►Cstream_writer_formatter<> | |
| Cdsp_preset_builder | Helper |
| Cui_element_config_builder | Helper |
| Cstring_filter_noncasesensitive | |
| Cstring_format_title | |
| Cstring_lower | |
| Cstring_upper | |
| Cstring_utf8_from_window | |
| ►Csystem_time_callback | |
| Csystem_time_callback_impl | |
| ►CT | |
| ►Cservice_impl_single_t< T > | Template implementing dummy version of reference-counting features of service_base. Intended for static/local/member instantiation: "static service_impl_single_t<someclass> myvar(params);". Because reference counting features are disabled (dummy reference counter), code instantiating it is responsible for deleting it as well as ensuring that no references are active when the object gets deleted.
Note that some constructor parameters such as NULL will need explicit typecasts to ensure correctly guessed types for constructor function template (null string needs to be (const char*)NULL rather than just NULL, etc) |
| Cservice_factory_single_transparent_t< T > | |
| Cservice_impl_t< T > | Template implementing reference-counting features of service_base. Intended for dynamic instantiation: "new service_impl_t<someclass>(param1,param2);"; should not be instantiated otherwise (no local/static/member objects) because it does a "delete this;" when reference count reaches zero.
Note that some constructor parameters such as NULL will need explicit typecasts to ensure correctly guessed types for constructor function template (null string needs to be (const char*)NULL rather than just NULL, etc) |
| Cservice_obscure_refcounting< T > | Special hack to ensure errors when someone tries to ->service_add_ref()/->service_release() on a service_ptr_t |
| ►Ct_base | |
| ►Cfoobar2000_io::file_readonly_t< t_base > | Implementation helper - contains dummy implementations of methods that modify the file |
| Cfoobar2000_io::file_streamstub | |
| ►Ct_baseclass | |
| ►Cdsp_impl_base_t< t_baseclass > | Helper class for implementing dsps. You should derive from dsp_impl_base instead of from dsp directly.
The dsp_impl_base_t template allows you to use a custom interface class as a base class for your implementation, in case you provide extended functionality.
Use dsp_factory_t<> template to register your dsp implementation. The implementation - as required by dsp_factory_t<> template - must also provide following methods:
A constructor taking const dsp_preset&, initializing the DSP with specified preset data.
static void g_get_name(pfc::string_base &); - retrieving human-readable name of the DSP to display.
static bool g_get_default_preset(dsp_preset &); - retrieving default preset for this DSP. Return value is reserved for future use and should always be true.
static GUID g_get_guid(); - retrieving GUID of your DSP implementation, to be used to identify it when storing DSP chain configuration.
static bool g_have_config_popup(); - retrieving whether your DSP implementation supplies a popup dialog for configuring it.
static void g_show_config_popup(const dsp_preset & p_data,HWND p_parent, dsp_preset_edit_callback & p_callback); - displaying your DSP's settings dialog; called only when g_have_config_popup() returns true; call p_callback.on_preset_changed() whenever user has made adjustments to the preset data.
|
| Cdsp_sample | |
| Ct_core_version_data | |
| Ct_cuesheet_index_list | |
| Ct_font_description | |
| Ct_modal_dialog_entry | |
| ►Ct_myclass | |
| Cservice_impl_single_t< t_myclass > | |
| Ct_pcmspec | Structure describing PCM audio data format, with basic helper functions |
| Ct_playback_queue_item | |
| Ct_replaygain_config | Structure storing ReplayGain configuration: album/track source data modes, gain/peak processing modes and preamp values |
| Ct_samplespec | |
| ►Ctag_write_callback | Callback interface for write-tags-to-temp-file-and-swap scheme, used for ID3v2 tag updates and such where entire file needs to be rewritten. As a speed optimization, file content can be copied to a temporary file in the same directory as the file being updated, and then source file can be swapped for the newly created file with updated tags. This also gives better security against data loss on crash compared to rewriting the file in place and using memory or generic temporary file APIs to store content being rewritten |
| Ctag_write_callback_dummy | |
| ►CTBase | |
| CImplementCOMRefCounter< TBase > | Simple implementation of a COM reference counter. The initial reference count is zero, so it can be used with pfc::com_ptr_t<> with plain operator=/constructor rather than attach() |
| ►CTClass | |
| CCAddDummyMessageMap< TClass > | |
| ►CCWindowFixSEH< TClass > | |
| CCWindowAutoLifetime< TClass > | |
| CImplementBumpableElem< TClass > | |
| CImplementModelessTracking< TClass > | |
| ►CTCtrl | |
| CCAltFontCtrl< TCtrl > | |
| ►CTDialog | |
| Cpreferences_page_instance_impl< TDialog > | |
| Cthreaded_process_status | Callback class passed to your threaded_process client code; allows you to give various visual feedback to the user |
| CThreadUtils::CObjectQueue< TWhat > | |
| CThreadUtils::CSingleThreadWrapper< TBase, processMsgs >::command | |
| ►CTImpl | |
| Cui_element_impl< TImpl, TInterface >::ui_element_instance_impl_helper | |
| ►CTInterface | |
| Cui_element_impl< TImpl, TInterface > | |
| ►Cui_element_impl< ImplementBumpableElem< TImpl >, TInterface > | |
| Cui_element_impl_visualisation< TImpl, TInterface > | |
| Cui_element_impl_withpopup< TImpl, TInterface > | |
| ►Ctitleformat_hook | |
| Ctitleformat_hook_impl_file_info | |
| Ctitleformat_hook_impl_list | |
| Ctitleformat_hook_impl_splitter | |
| Ctitleformat_hook_function_params | |
| Ctitleformat_object_wrapper | |
| ►Ctitleformat_text_filter | |
| Ccreate_directory_helper::titleformat_text_filter_myimpl | |
| Ctitleformat_text_filter_impl_filename_chars | |
| Ctitleformat_text_filter_impl_reserved_chars | |
| Ctitleformat_text_filter_nontext_chars | |
| ►Ctitleformat_text_out | |
| Ctitleformat_text_out_impl_filter_chars | |
| Ctitleformat_text_out_impl_string | |
| ►CTList | |
| Ccfg_objListEx< TList > | |
| ►CTMap | |
| Ccfg_objMap< TMap > | |
| ►CTObj | |
| Ccfg_obj< TObj > | |
| ►Ctrack_property_callback | Callback interface for track_property_provider::enumerate_properties() |
| ►Ctrack_property_callback_v2 | |
| Ctrack_property_callback_v2_proxy | |
| ►Ctrack_property_provider_v3_info_source | |
| Ctrack_property_provider_v3_info_source_impl | |
| CTypeFind | |
| CuCallStackTracker | |
| CuFindFile | |
| Cui_element_instance_callback_receiver | Ui_element_instance_callback implementation helper |
| Cui_element_min_max_info | |
| Cui_element_notify_get_element_labels_callback | |
| ►Cui_selection_callback | |
| Cui_selection_callback_impl_base | Ui_selection_callback implementation helper with autoregistration - do not instantiate statically |
| Cui_selection_callback_impl_base_ex< flags > | |
| CuResource | |
| CuStringPrintf | |
| Cvolume_callback | |
| CwavWriterSetup_t | |
| Cwin32_accelerator | |
| ►Cwin32_event | |
| Cpfc::event | |
| Cwin32_font | |
| Cwin32_icon | |
| Cwin32_menu | |
| Cwinapi_substitute::_REASON_CONTEXT | |
| Cwinapi_substitute::_REASON_CONTEXT.Reason | |
| Cwinapi_substitute::_REASON_CONTEXT.Reason.Detailed | |
| CwinLocalFileScope | |
| ►C_parentClass | |
| CCWindowFixSEH< _parentClass > | |
| ►CCDCHandle | |
| CCBackBufferScope | |
| ►CCFont | |
| CCFontScaled | |
| CCFontHandle | |
| ►CCWindow | |
| ►CCWindowRegisteredT< CSeparator > | |
| ►CCTextControl< CSeparator > | |
| CCSeparator | |
| ►CCWindowRegisteredT< TClass > | |
| CCTextControl< TClass > | |
| ►CE | |
| Coutput_entry_impl_t< T, E > | Helper; implements output_entry for specific output class implementation. output_entry methods are forwarded to static methods of your output class. Use output_factory_t<myoutputclass> instead of using this class directly |
| Ctemplate alloc< t_item > | |
| ►CB | |
| Cpfc::ptr_list_t< T, B > | |
| ►Cstring8_t< pfc::alloc_fast_aggressive > | |
| Cconsole::formatter | Usage: console::formatter() << "blah " << somenumber << " asdf" << somestring; |
| Cpfc::format_array | |
| Cpfc::format_guid_cpp | |
| Cpfc::string_printf | |
| Cpfc::string_printf_va | |
| CuDebugLog | |
| Ct_alloc< t_item > | |
| ►Ct_base | |
| Cinput_impl_interface_wrapper_t< I, t_base > | Used internally by standard input_entry implementation; do not use directly. Translates input_decoder / input_info_reader / input_info_writer calls to input_impl calls |
| Cpfc::__exception_with_message_t< t_base > | |
| Cpfc::instanceTracker< t_base > | |
| ►Ct_entry | |
| Cdsp_entry_impl_nopreset_t< T, t_entry > | |
| Cdsp_entry_impl_t< T, t_entry > | |
| Cdsp_entry_v2_impl_t< T, t_entry > | |
| ►CTBaseClass | |
| CCWindowRegisteredT< TClass, TBaseClass > | |
1.8.11
