| adam_callback_suite_t | Callback class for the Adam parser |
| aggregate_name_t | |
| aggregate_pair< T1, T2 > | |
| aggregate_type_info_t | |
| alert_helper_t | |
| aligned_storage< T > | |
| always_true< T > | |
| any_bidirectional_iterator_instance< V, R, D > | |
| any_bidirectional_iterator_interface< V, R, D > | |
| any_iterator | An iterator wrapping another iterator of the same element type; a "polymorphic" iterator |
| any_random_access_iterator_instance< V, R, D > | |
| any_random_access_iterator_interface< V, R, D > | |
| any_regular_t | A runtime polymorphic type similar to boost::any which can hold any type which models Regular |
| asl_cel_format | |
| assemblage_t | |
| assign | |
| attribute_set_t | An associated array based on adobe::token_range_t. A utility class for the xml_parser_t |
| auto_ptr< X, Traits > | The adobe::auto_ptr<> template adds a number of extensions to std::auto_ptr<> |
| auto_resource< X, Traits > | The template class auto_resource< X, Traits > provides similar functionality to auto_ptr for resources for which the pointer is opaque refered to by a non-pointer type |
| back_move_iterator< C > | Similar to std::back_insert_iterator but with move semantics, for movable types, otherwise with copy semantics |
| bad_cast | An exception class thrown during ASL failures to cast |
| basic_bounded_width< charT, traits > | |
| basic_format< T > | |
| basic_omanipulator< ArgumentType, charT, traits > | |
| basic_omanipulator2< ArgumentType1, ArgumentType2, charT, traits > | |
| begin_atom< T > | |
| begin_bag | |
| behavior_t | |
| bidirectional_iter< V, R, D > | |
| binary_compose< F, G, H > | |
| bitpath_t | |
| bitwise_and< T > | operator() returns x & y |
| bitwise_or< T > | operator() returns x | y |
| bitwise_xor< T > | operator() returns x ^ y |
| button_state_descriptor_t | |
| button_t | Button widget |
| capture_allocator< T > | |
| capture_allocator< void > | |
| chain< ArgStreamFirst, ArgStreamSecond > | Chain 2 arg_streams together by calling the first stream until depleted, then calling the second |
| checkbox_t | Checkbox widget |
| child_adaptor< Forest > | |
| child_iterator< I > | An iterator used to traverse the children of a specific node in a forest |
| circular_queue< T > | A queue with a fixed capacity which supports putting back elements. Pushing more elements than there is capacity will pop the least recently pushed elements |
| dirty_value< T >::cleaner | |
| closed_hash_map< Key, T, Hash, Pred, A > | A hash based associative container |
| closed_hash_set< T, KeyTransform, Hash, Pred, A > | A hash based associative container |
| closer_predicate< T > | |
| command_system_t | |
| vector< T, A >::header_t::compact_header_t | |
| closed_hash_set< T, KeyTransform, Hash, Pred, A >::header_t::compact_header_t | |
| compare_members_t< T, R, Compare > | Utility class for adobe::compare_members |
| function< R()>::concept_t | |
| concept_t | |
| const_once_name_t | Utility wrapper to construct name_t without initializing the string pointer |
| constructor< T > | |
| control_button_t | |
| controller | |
| controller_model_type< C > | |
| controller_model_type< adobe::image_t > | |
| controller_model_type< image_t > | |
| controller_model_type< poly_controller_t > | |
| controller_model_type< preview_t > | |
| edit_number_t::controller_t | |
| ControllerConcept< T > | |
| ControllerConcept< T * > | |
| copy_on_write< T, A > | A copy-on-write wrapper for any model of Regular |
| copy_sink< T, U, R > | Copy_sink and move_sink are used to select between overloaded operations according to whether type T is movable and convertible to type U |
| copyable | "Handle" class used in poly<copyable> implementation |
| counter_t | A thread safe counter |
| counting_output_iterator | |
| dancing_links | An optimized implementation of the 1-cover problem [class under review] |
| dancing_links_t | |
| debounce_t< ModeType > | Utility class to short-circuit feedback issues with model-view-controller systems |
| dec< T > | Operator-- wrapped in a function object |
| delete_array | A function object for type T that invokes delete[] on an array of T |
| delete_ptr | A function object for type T that invokes delete on a T* |
| delete_ptr_trait< T * > | |
| delete_ptr_trait< T(*)[]> | |
| depth_fullorder_cursor | An iterator-like type for the depth-tracked traversal of a forest |
| depth_fullorder_iterator< I > | |
| dialog_result_t | |
| dictionary_arg_stream< Dictionary, InputRange, NoThrow > | Dictionary_arg_stream implements the arg_stream interface |
| dictionary_arg_stream< Dictionary, InputRange, std::nothrow_t > | |
| dictionary_arg_stream_base< Dictionary, InputRange, NoThrow > | |
| dirty_value< T > | |
| display_compositor_t< Control, UserData > | |
| display_number_t | Display number view |
| display_t | |
| dnd_converter_dest_type< Converter > | |
| dnd_converter_source_type< Converter > | |
| drag_and_drop_converter | |
| drag_and_drop_handler< SourceType, TargetType > | |
| drag_and_drop_handler_platform_data< SourceType, TargetType > | |
| DragAndDropConverterConcept< DragAndDropConverter > | DragAndDropConverter concept requirement |
| DragAndDropConverterConcept< boost::reference_wrapper< DragAndDropConverter > > | |
| dynamic_menu_item_set_view_t | |
| edge_iterator< I, Edge > | An iterator used to traverse a specific edge type within a forest |
| edit_number_platform_data_t | |
| edit_number_t | Edit number widget |
| edit_number_unit_subwidget_t | |
| edit_text_ctor_block_t | |
| edit_text_t | Edit text widget |
| element< N, T > | |
| element< 0, pair< T1, T2 > > | |
| element< 0, std::pair< T1, T2 > > | |
| element< 1, pair< T1, T2 > > | |
| element< 1, std::pair< T1, T2 > > | |
| empty_base< Derived > | |
| empty_base_t< Derived > | |
| empty_ptr< T * > | |
| empty_ptr< T(*)[]> | |
| empty_t | An empty regular- and less-than-comparable- type |
| endian | |
| endian_swap< SourceEndian > | |
| equal_to | |
| equality_comparable | |
| equivalent< O > | |
| eve_callback_suite_t | |
| eve_client_holder | |
| eve_t | Eve engine |
| event_handler_t | |
| extents_slices_t | A utility class for referencing the two slices of a extents_t |
| extents_t | An intrinsic geometry class for objects with a graphical representation |
| external_model_t | |
| factory_token_t | |
| file_monitor_platform_data_t | |
| file_monitor_t | |
| file_slurp< T > | |
| filter_fullorder_cursor | An iterator-like type for fullorder (pre- and post-order) traversal of a forest |
| filter_fullorder_iterator< I, P > | |
| force_relayout_view_adaptor< View > | |
| forest< T > | A homogeneous hierarchical structure class |
| format_base | |
| format_element_t | |
| function< R()> | |
| function_not_present | |
| function_pack_t | Container class to unify a collecton of functions under the same function signature.This class will collect registered functions by one of two methods: as functions with named or unnamed arguments. If the former, the function is then invoked with an array_t containing arguments in the order in which they should be passed to the original function. If the latter, the function is invoked with an dictionary_t containing arguments bound to keys that match those required by the function |
| function_traits< boost::function< F > > | |
| function_traits< R(&)()> | |
| function_traits< R(&)(A1)> | |
| function_traits< R(&)(A1, A2)> | |
| function_traits< R(&)(A1, A2, A3)> | |
| function_traits< R(&)(A1, A2, A3, A4)> | |
| function_traits< R(&)(A1, A2, A3, A4, A5)> | |
| function_traits< R(&)(A1, A2, A3, A4, A5, A6)> | |
| function_traits< R(&)(A1, A2, A3, A4, A5, A6, A7)> | |
| function_traits< R()> | |
| function_traits< R(*)()> | |
| function_traits< R(*)(A1)> | |
| function_traits< R(*)(A1, A2)> | |
| function_traits< R(*)(A1, A2, A3)> | |
| function_traits< R(*)(A1, A2, A3, A4)> | |
| function_traits< R(*)(A1, A2, A3, A4, A5)> | |
| function_traits< R(*)(A1, A2, A3, A4, A5, A6)> | |
| function_traits< R(*)(A1, A2, A3, A4, A5, A6, A7)> | |
| function_traits< R(A1)> | |
| function_traits< R(A1, A2)> | |
| function_traits< R(A1, A2, A3)> | |
| function_traits< R(A1, A2, A3, A4)> | |
| function_traits< R(A1, A2, A3, A4, A5)> | |
| function_traits< R(A1, A2, A3, A4, A5, A6)> | |
| function_traits< R(A1, A2, A3, A4, A5, A6, A7)> | |
| function_traits< R(A1::*)() const > | |
| function_traits< R(A1::*)()> | |
| function_traits< R(A1::*)(A2) const > | |
| function_traits< R(A1::*)(A2)> | |
| function_traits< R(A1::*)(A2, A3) const > | |
| function_traits< R(A1::*)(A2, A3)> | |
| function_traits< R(A1::*)(A2, A3, A4) const > | |
| function_traits< R(A1::*)(A2, A3, A4)> | |
| function_traits< R(A1::*)(A2, A3, A4, A5) const > | |
| function_traits< R(A1::*)(A2, A3, A4, A5)> | |
| function_traits< R(A1::*)(A2, A3, A4, A5, A6) const > | |
| function_traits< R(A1::*)(A2, A3, A4, A5, A6)> | |
| function_traits< R(A1::*)(A2, A3, A4, A5, A6, A7) const > | |
| function_traits< R(A1::*)(A2, A3, A4, A5, A6, A7)> | |
| generator_t< Result > | A function object for value generation within a domain |
| get_element< N, T > | |
| get_element< 0, pair< T1, T2 > > | |
| get_element< 0, std::pair< T1, T2 > > | |
| get_element< 1, pair< T1, T2 > > | |
| get_element< 1, std::pair< T1, T2 > > | |
| greater | |
| greater_equal | |
| group_t | Group container widget |
| with_transform< ArgStream, Transformer >::has_entry_if_has_inverse_lookup< Class, R, bool > | |
| with_transform< ArgStream, Transformer >::has_entry_if_has_inverse_lookup< Class, R, true > | |
| has_eof_member< T > | |
| has_get_dictionary_entry_function< Dictionary, Key, R > | |
| has_get_dictionary_entry_template< Dictionary, Key > | |
| with_transform< ArgStream, Transformer >::has_inverse_lookup< Class > | |
| has_nothrow_constructor< adobe::version_1::closed_hash_map< Key, T, Hash, Pred, A > > | |
| has_nothrow_constructor< adobe::version_1::closed_hash_set< T, KeyTransform, Hash, Pred, A > > | |
| has_nothrow_constructor< adobe::version_1::string16_t > | |
| has_nothrow_constructor< adobe::version_1::string_t > | |
| with_transform< ArgStream, Transformer >::has_transform< Class, R > | |
| has_trivial_constructor< adobe::version_1::empty_t > | |
| has_trivial_destructor< adobe::version_1::empty_t > | |
| has_type_type< T > | T::type a valid type (or a compile error?) |
| hash_index< T, H, C, P > | |
| identity< T > | |
| identity_element< Op > | |
| identity_element< std::multiplies< T > > | Specialization of identity_element for std::multiplies<T> |
| identity_element< std::plus< T > > | Specialization of identity_element for std::plus<T> |
| type_or_default< T, Default >::if_has_type< condition, IFtype, ELSEtype > | |
| type_or_default< T, Default >::if_has_type< false, IFtype, ELSEtype > | |
| if_range_base< NoThrow, isRange > | |
| if_range_base< std::nothrow_t, false > | |
| if_range_base< void, false > | |
| if_range_base< void, true > | |
| if_range_else_key< NoThrow, Dictionary, T > | |
| image_button_state_descriptor_t | |
| image_event_handler_t | |
| image_t | Image widget |
| inc< T > | Operator++ wrapped in a function object |
| indents | |
| index_iterator< F, T, R, I, D > | An iterator over elements which are the result of applying a function to an index |
| indirect< T > | |
| indirect_t | Adapter used to convert pointers to references |
| invoker< F, From, To > | |
| invoker< F, To, To > | |
| is_convertible< T, U > | |
| is_empty< adobe::version_1::empty_t > | |
| is_member< I, O > | |
| is_movable< T > | The is_movable trait can be used to identify movable types |
| is_movable< copy_on_write< T, A > > | |
| is_pod< adobe::name_t > | |
| is_pod< adobe::version_1::empty_t > | |
| is_range< T > | Does T model the boost::range concepts? |
| is_range_for_dictionary< Dictionary, Range > | |
| iter< V, R, D > | |
| javascript_format | |
| key_handler | |
| key_type< Dictionary, DefaultKey, false > | |
| key_type< Dictionary, DefaultKey, true > | |
| keyboard_t | |
| KeyHandlerConcept< Handler > | |
| label_t | Label widget |
| layout_attributes_alignment_t | A utility class for referencing the alignment characteristics in layout_attributes_t |
| layout_attributes_placement_t | |
| layout_attributes_t | Layout data interface from the client to the engine |
| less | |
| less< adobe::version_1::type_info_t > | Compares the x and y. Returns true if x precedes y in the implementationís collation order |
| less_equal | |
| attribute_set_t::less_key_only_t | |
| attribute_set_t::less_t | |
| lex_stream_t | |
| lex_token_t< E > | |
| line_position_t | A type detailing parser position information |
| link_t | Link widget |
| logical_and | |
| logical_not | |
| logical_or | |
| logical_xor< C1, C2 > | Xor funtion object |
| make_type_info< T, Any > | |
| make_type_info< const T0[Size], Any > | |
| make_type_info< T0[Size], Any > | |
| manipulator_base | |
| marshaled_exception | |
| md5_t | MD5 hash generator |
| mem_data_t< T, R > | Adaptor similar to boost::mem_fn() used by boost::bind |
| mem_data_t< const T, R > | |
| member_test_helper< size_t > | |
| menu_system_t | |
| message_handler_t | |
| metric_extractor_t | Utility class to access widget metrics for the Macintosh |
| modal_dialog_t | |
| function< R()>::model< T > | |
| mouse_in_out_event_handler_t | |
| mouse_in_out_event_tag_t | |
| mouse_wheel_handler_t | |
| move_from< T > | Move_from is used for move_ctors |
| move_sink< T, U, R > | Move_sink and copy_sink are used to select between overloaded operations according to whether type T is movable and convertible to type U |
| my_class_t | A one-line synopsis of what the class does |
| name_t | A character string class for immutable strings |
| name_t | |
| nearest_cast_fn< A, R > | |
| nearest_cast_fn< A, double > | |
| nearest_cast_fn< A, float > | |
| new_delete_t | |
| no_more_args | |
| no_struct | |
| nonarg | Empty-set arg stream has no arguments. Not sure what this might be useful for |
| noncopyable | |
| not_equal_to | |
| notify_on_write< T, Notifier > | |
| null_output_iterator_t | A stub iterator that models OutputIterator and outputs nothing |
| number_formatter_platform_data_t | |
| number_formatter_t | |
| optimized_storage_type< ConcreteType, Interface > | Authors of adobe::poly concept representatives must derive their instance class from this. See of adobe::poly_placeable_instance, for example. This metafunction is used in the implementation of the small storage optimization |
| optional_panel_t | Optional panel container widget |
| os_exception | |
| pair< T1, T2 > | |
| panel_t | Panel container widget |
| pdf_format | |
| periodical_platform_data_t | |
| periodical_t | |
| place_data_t | Layout data interface from the engine to the client |
| placeable | Representative of adobe::PlaceableConcept so that placeable models adobe::PlaceableConcept when T does |
| placeable_twopass | |
| PlaceableConcept< T > | Concept map and constraints checking for the Placeable concept |
| PlaceableConcept< T * > | Concept map and constraints checking for to allow boost::reference_wrapper<T> to model this concept when T does |
| PlaceableTwoPassConcept< T > | Concept map and constraints checking for the PlaceableTwoPass concept |
| PlaceableTwoPassConcept< T * > | Concept map and constraints checking for to allow boost::reference_wrapper<T> to model this concept when T does |
| plus_asymmetric< T1, T2 > | Plus function object whose arguments may be of different type |
| point_2d< T > | |
| pointer_to< T > | |
| pointer_to_ternary_function< T, U, V, R > | |
| poly< F > | adobe::poly<foo> will be a runtime polymorphic value type wrapper modelling a concept represented by foo |
| poly_base< I, Instance > | Authors of a Concept representative F, intended as a template parameter to adobe::poly, will inherit from adobe::poly_base. The first template parameter for adobe::poly_base provides the virtual interface for the concept representative. The second template parameter for adobe::poly_base must inherit from the Concept interface representative. The author's third duty is to provide forwarding functions in a their Concept representative. See the placeable_concept.hpp header file for details |
| poly_controller_instance< T > | |
| poly_controller_interface | |
| poly_copyable_instance< T > | Implementation of a trivial poly interface in terms of types modeling Copyable . Used in poly<copyable> implementation |
| poly_copyable_interface | Abstract interface providing signatures needed to implement "handle" objects modeling a Value (Copyable/Movable) concept. Authors of adobe::poly classes must derive their interfaces from this. See adobe::poly_placeable_interface for an example |
| poly_drag_and_drop_converter_instance< T > | |
| poly_drag_and_drop_converter_interface | |
| poly_iterator_instance< V, R, D > | |
| poly_iterator_interface< V, R, D > | |
| poly_key_handler_instance< T > | |
| poly_key_handler_interface | |
| poly_placeable_instance< T > | Implementation of virtual interface for the poly<placeable> modeling adobe::PlaceableConcept |
| poly_placeable_interface | Pure virtual interface for the poly<placeable> modeling adobe::PlaceableConcept |
| poly_placeable_twopass_instance< T > | Implementation of virtual interface for the poly<placeable_twopass> modeling adobe::PlaceableTwoPassConcept |
| poly_placeable_twopass_interface | Pure virtual interface for poly<placeable_twopass> modeling adobe::PlaceableTwoPassConcept |
| poly_regular_instance< T > | Implementation of a trivial poly interface in terms of types modeling regular . Used in poly<regular> implementation |
| poly_regular_interface | Virtual interface for RegularConcept. Used in poly<regular> implementation |
| poly_sequence_controller< T > | |
| poly_sequence_controller_instance< T > | Poly_ instance for implementations that model the SequenceController concept |
| poly_sequence_controller_interface< T > | Poly_ holder for implementations that model the SequenceController concept |
| poly_sequence_model< T > | |
| poly_sequence_model_instance< T > | Poly_ instance for implementations that model the SequenceModel concept |
| poly_sequence_model_interface< T > | Poly_ concept for implementations that model the SequenceModel concept |
| poly_sequence_view< T > | |
| poly_sequence_view_instance< T > | Poly_ instance for implementations that model the SequenceView concept |
| poly_sequence_view_interface< T > | Poly_ concept for implementations that model the SequenceView concept |
| poly_view_instance< T > | Implementation of poly_view_interface in terms of types modeling ViewConcept . Used in poly<view> implementation |
| poly_view_interface | Virtual interface for ViewConcept. Used in poly<view> implementation |
| popup_t | Popup widget |
| presets_t | Presets widget |
| preview_t | Preview widget |
| progress_bar_t | Progress bar widget |
| promote< T > | A struct for compile-time type promotion |
| promote< aggregate_name_t > | |
| promote< const char * > | |
| promote< float > | |
| promote< int > | |
| promote< long > | |
| promote< short > | |
| promote< static_name_t > | |
| promote< std::string > | |
| promote< unsigned int > | |
| promote< unsigned long > | |
| promote< unsigned short > | |
| ptr_traits< auto_ptr< T, Traits > > | |
| ptr_traits< auto_resource< T, Traits > > | |
| ptr_traits< std::auto_ptr< T > > | |
| ptr_traits< T * > | This section defines requirements on classes representing pointer traits. The template class ptr_traits< ptrT > is defined along with several specializations |
| ptr_traits< T(*)[]> | |
| radio_button_t | Radio button widget |
| random_access_iter< V, R, D > | |
| ptr_traits< T * >::rebind< U > | |
| ptr_traits< std::auto_ptr< T > >::rebind< U > | |
| ptr_traits< T(*)[]>::rebind< U > | |
| capture_allocator< void >::rebind< U > | |
| capture_allocator< T >::rebind< U > | |
| regular | "Handle" class used in poly<regular> implementation |
| RegularConcept< T > | |
| adam_callback_suite_t::relation_t | Struct containing details of a relation expression for client callbacks from the Adam parser |
| sheet_t::relation_t | Adam support class for related relationships |
| eve_callback_suite_t::relation_t | |
| remove_cv_ref< T > | |
| resource_context_t | |
| result_type< F > | Result_type<F>::type is the return type of the function f |
| reveal_t | Reveal widget |
| reverse_fullorder_cursor | An iterator-like type for reverse fullorder (pre- and post-order) traversal of a forest |
| reverse_fullorder_iterator< I > | |
| rset< Type1, Type2, Type1Equality, Type2Equality > | A bidirectional lookup table intended for a small set of elements |
| runtime_cast_t< R, T > | |
| runtime_cast_t< R, any_regular_t * > | |
| runtime_cast_t< R, any_regular_t > | |
| runtime_cast_t< R, auto_ptr< T, Traits > > | |
| runtime_cast_t< R, auto_resource< T, Traits > > | |
| runtime_cast_t< R, const any_regular_t * > | |
| runtime_cast_t< R, const any_regular_t > | |
| runtime_cast_t< R, std::auto_ptr< T > > | |
| segmented_iterator< I > | |
| select< T > | |
| selection_t | A container used to represent a linear boolean selection |
| separator_t | Separator widget |
| sequence_controller< T > | Poly_ holder for implementations that model the SequenceController concept |
| sequence_controller_value_type< SequenceController > | SequenceController concept requirement |
| sequence_key< T > | |
| sequence_model< T > | |
| sequence_model_base< T > | Poly_ holder for implementations that model the SequenceModel concept |
| sequence_model_demultiplexer< T > | |
| sequence_model_key_type< SequenceModel > | SequenceModel concept requirement |
| sequence_model_multiplexer< T > | |
| sequence_model_value_type< SequenceModel > | SequenceModel concept requirement |
| sequence_t< T > | A function object for sequence generation within a domain |
| sequence_view< T > | Poly_ holder for implementations that model the SequenceView concept |
| sequence_view_cow_value_type< SequenceView > | |
| sequence_view_demultiplexer_t | |
| sequence_view_key_type< SequenceView > | SequenceView concept requirement |
| sequence_view_multiplexer< T > | |
| sequence_view_value_type< SequenceView > | |
| SequenceControllerConcept< SequenceController > | SequenceController concept requirement |
| SequenceControllerConcept< boost::reference_wrapper< T > > | |
| SequenceModelConcept< SequenceModel > | SequenceModel concept requirement |
| SequenceModelConcept< boost::reference_wrapper< T > > | |
| SequenceViewConcept< SequenceView > | View concept for sequences |
| SequenceViewConcept< boost::reference_wrapper< T > > | |
| set_monitor_t | Adam support class |
| set_next_fn< child_iterator< I > > | |
| sha1_t | A bit-oriented implementation of the SHA-1 Secure Hash Algorithm |
| sha224_t | A bit-oriented implementation of the SHA-224 Secure Hash Algorithm |
| sha256_t | A bit-oriented implementation of the SHA-256 Secure Hash Algorithm |
| sha384_t | A bit-oriented implementation of the SHA-384 Secure Hash Algorithm |
| sha512_t | A bit-oriented implementation of the SHA-512 Secure Hash Algorithm |
| sheet_t | The fundamental data structure for the Property Model engine |
| short_name< T > | |
| signature< F > | Returns the function signature of the callable object type F |
| signature< boost::function< F > > | |
| single< T > | Holds a single value, and returns it as an arg n (default 1) times |
| place_data_t::slice_t | Element geometry for a single orientation of place_data_t |
| layout_attributes_t::slice_t | Placeable object geometry for a single orientation of layout_attributes_t |
| extents_t::slice_t | A class containing element geometry for a single orientation |
| slider_t | Slider widget |
| splitter_controller_adaptor< ModelType > | |
| static_name_t | Utility wrapper to construct name_t with strings of static storage duration |
| static_name_t | |
| static_table< KeyType, ValueType, Size, Traits > | A simple lookup table of fixed size. [under review] |
| static_table_traits< KeyType, ValueType > | A traits class for use with adobe::static_table |
| step_iterator_adaptor< DERIVED, IT, S_FN > | Step iterator adaptor |
| str_less_t | |
| stream_error_t | An exception class thrown during parsing failures |
| string16_t | |
| string16_t | Lightweight string class designed to hold UTF16 strings in fixed binary structure |
| string_t | Lightweight string class designed to hold UTF8 strings in fixed binary structure |
| string_t | |
| sublayout_t | |
| tab_group_t | Tab group container widget |
| tab_group_t::tab_t | Tab structure |
| table_index< Key, T, Transform, Compare > | Utility class for indexing objects based on specific member variable values |
| ternary_function< T, U, V, R > | |
| timer_t | |
| timer_t | A class for measuring periods of elapsed time. Can also accrue split times for some basic statistical reporting |
| toggle_t | Toggle widget |
| totally_ordered | |
| traits< T > | Defines any traits that help with the implementation of arg_stream::call() and/or helper objects like arg_stream::chain |
| traits< chain< S1, S2 > > | |
| traits< nonarg > | |
| traits< single< T > > | |
| transform | Function object used in binding for instance value access |
| any_regular_t::transform< T > | Function object used in binding for instance value access |
| transposer< F > | |
| poly_sequence_model_instance< T >::type< V > | |
| poly_sequence_controller_instance< T >::type< V > | |
| poly_iterator_instance< V, R, D >::type< I > | |
| any_random_access_iterator_instance< V, R, D >::type< I > | |
| poly_sequence_view_instance< T >::type< V > | |
| any_bidirectional_iterator_instance< V, R, D >::type< I > | |
| type_info_t | Partial re-implementation of standard type_info |
| type_or_default< T, Default > | |
| unary_compose< F, G > | |
| unit_t | |
| uuid_t | |
| value_iterator< I, F > | |
| value_range_format_t | |
| vector< T, A > | |
| view | "Handle" class used in poly<view> implementation |
| view_model_type< View > | |
| view_model_type< adobe::image_t > | |
| view_model_type< image_t > | |
| view_model_type< preview_t > | |
| edit_number_t::view_t | |
| ViewConcept< T > | |
| ViewConcept< boost::reference_wrapper< T > > | |
| virtual_machine_t | |
| visible_change_queue_t | |
| vm_lookup_t | |
| widget_factory_t | |
| widget_node_t | |
| window_server_t | |
| window_t | Window container widget |
| with_transform< ArgStream, Transformer > | |
| xml_format | |
| xml_parser_t< O > | A relatively lightweight and simple xml (subset) parser |
| xstring_context_t | Scope-based runtime context stack for glossary lookups |
| yes_struct | |
| zuid_t | UUID-like identifier generator |
