| 
| void  | init_cameras (vr::vr_kit *kit_ptr) | 
|   | 
| void  | start_camera () | 
|   | 
| void  | stop_camera () | 
|   | 
| void  | compute_intersections (const vec3 &origin, const vec3 &direction, int ci, const rgb &color) | 
|   | compute intersection points of controller ray with movable boxes  
  | 
|   | 
| void  | on_status_change (void *kit_handle, int ci, vr::VRStatus old_status, vr::VRStatus new_status) | 
|   | keep track of status changes  
  | 
|   | 
| void  | on_device_change (void *kit_handle, bool attach) | 
|   | register on device change events  
  | 
|   | 
| void  | construct_table (float tw, float td, float th, float tW) | 
|   | construct boxes that represent a table of dimensions tw,td,th and leg width tW  
  | 
|   | 
| void  | construct_room (float w, float d, float h, float W, bool walls, bool ceiling) | 
|   | construct boxes that represent a room of dimensions w,d,h and wall width W  
  | 
|   | 
| void  | construct_environment (float s, float ew, float ed, float w, float d, float h) | 
|   | construct boxes for environment  
  | 
|   | 
| void  | construct_movable_boxes (float tw, float td, float th, float tW, size_t nr) | 
|   | construct boxes that represent a table of dimensions tw,td,th and leg width tW  
  | 
|   | 
| void  | build_scene (float w, float d, float h, float W, float tw, float td, float th, float tW) | 
|   | construct a scene with a table  
  | 
|   | 
| std::string  | get_type_name () | 
|   | 
| void  | stream_help (std::ostream &os) | 
|   | overload to stream help information to the given output stream  
  | 
|   | 
| void  | on_set (void *member_ptr) | 
|   | this callback is called when the set_void method has changed a member and can be overloaded in derived class  
  | 
|   | 
| bool  | handle (cgv::gui::event &e) | 
|   | overload and implement this method to handle events  
  | 
|   | 
| bool  | init (cgv::render::context &ctx) | 
|   | this method is called after creation or recreation of the context, return whether all necessary functionality is supported  
  | 
|   | 
| void  | clear (cgv::render::context &ctx) | 
|   | clear all objects living in the context like textures or display lists  
  | 
|   | 
| void  | init_frame (cgv::render::context &ctx) | 
|   | this method is called in one pass over all drawables before the draw method  
  | 
|   | 
| void  | draw (cgv::render::context &ctx) | 
|   | overload to draw the content of this drawable  
  | 
|   | 
| void  | finish_draw (cgv::render::context &ctx) | 
|   | this method is called when the current drawable is left in a tree traversal that calls the draw method  
  | 
|   | 
| void  | create_gui () | 
|   | you must overload this for gui creation  
  | 
|   | 
| bool  | save_boxes (const std::string fn, const std::vector< box3 > &boxes, const std::vector< rgb > &box_colors, const std::vector< vec3 > &box_translations, const std::vector< quat > &box_rotations) | 
|   | stores configuration of the movable boxes inside a file  
  | 
|   | 
| bool  | load_boxes (const std::string fn, std::vector< box3 > &boxes, std::vector< rgb > &box_colors, std::vector< vec3 > &box_translations, std::vector< quat > &box_rotations) | 
|   | loads boxes stored by the save_boxes method from a file  
  | 
|   | 
|   | node (const std::string &name="") | 
|   | construct from name  
  | 
|   | 
| node_ptr  | get_parent () const | 
|   | return the parent node  
  | 
|   | 
| base_ptr  | get_root () const | 
|   | return the root node by traversing parents until no more parent is available  
  | 
|   | 
| void  | set_parent (node_ptr _parent) | 
|   | set a new parent node  
  | 
|   | 
| node_ptr  | get_node () | 
|   | cast upward to node  
  | 
|   | 
| const_node_ptr  | get_node_const () | 
|   | cast upward to const node  
  | 
|   | 
| std::string  | get_type_name () const | 
|   | overload to return the type name of this object  
  | 
|   | 
|   | named (const std::string &name="") | 
|   | construct from name  
  | 
|   | 
| const std::string &  | get_name () const | 
|   | return the parent node  
  | 
|   | 
| void  | set_name (const std::string &_name) | 
|   | set a new parent node  
  | 
|   | 
| named_ptr  | get_named () | 
|   | cast upward to named  
  | 
|   | 
| const_named_ptr  | get_named_const () | 
|   | cast upward to const named  
  | 
|   | 
| virtual std::string  | get_default_options () const | 
|   | overload to provide default options for registration  
  | 
|   | 
| std::string  | get_name_or_type_name () const | 
|   | determine name of instance by checking cgv::base::named interface and in failure fallback to get_type_name()  
  | 
|   | 
| virtual void  | on_register () | 
|   | overload to handle register events that is sent after the instance has been registered  
  | 
|   | 
| virtual void  | unregister () | 
|   | overload to handle unregistration of instances  
  | 
|   | 
| virtual bool  | on_exit_request () | 
|   | overload to handle the appication exit request, return true if exiting is allowed and false otherwise  
  | 
|   | 
| virtual void  | stream_stats (std::ostream &) | 
|   | overload to show the content of this object  
  | 
|   | 
| virtual data::ref_ptr< group, true >  | get_group () | 
|   | perform downcast to group  
  | 
|   | 
| virtual data::ref_ptr< const named, true >  | get_named_const () const | 
|   | perform downcast to const named  
  | 
|   | 
| virtual data::ref_ptr< const node, true >  | get_node_const () const | 
|   | perform downcast to const node  
  | 
|   | 
| virtual data::ref_ptr< const group, true >  | get_group_const () const | 
|   | perform downcast to const group  
  | 
|   | 
| template<class T >  | 
| data::ref_ptr< T, true >  | cast () | 
|   | cast to arbitrary class, but use the casts to named, node and group from the interface  
  | 
|   | 
| template<class T >  | 
| data::ref_ptr< const T, true >  | cast_const () | 
|   | const cast to arbitrary class, but use the casts to named, node and group from the interface  
  | 
|   | 
| template<class T >  | 
| T *  | get_interface () | 
|   | use dynamic type cast to check for the given interface  
  | 
|   | 
| template<class T >  | 
| const T *  | get_const_interface () const | 
|   | use dynamic type cast to check for the given interface  
  | 
|   | 
| virtual void  | update () | 
|   | this virtual update allows for example to ask a view to update the viewed value. The default implementation is empty.  
  | 
|   | 
| virtual void *  | get_user_data () const | 
|   | this virtual method allows to pass application specific data for internal purposes  
  | 
|   | 
| virtual bool  | self_reflect (cgv::reflect::reflection_handler &) | 
|   | used for simple self reflection  
  | 
|   | 
| virtual std::string  | get_property_declarations () | 
|   | return a semicolon separated list of property declarations  
  | 
|   | 
| virtual bool  | set_void (const std::string &property, const std::string &value_type, const void *value_ptr) | 
|   | abstract interface for the setter of a dynamic property.  
  | 
|   | 
| virtual bool  | get_void (const std::string &property, const std::string &value_type, void *value_ptr) | 
|   | abstract interface for the getter of a dynamic property.  
  | 
|   | 
| virtual bool  | call_void (const std::string &method, const std::vector< std::string > ¶m_value_types, const std::vector< const void * > ¶m_value_ptrs, const std::string &result_type="", void *result_value_ptr=0) | 
|   | abstract interface to call an action  
  | 
|   | 
| void  | set (const std::string &property, const char *value) | 
|   | specialization of set method to support const char* as strings  
  | 
|   | 
| template<typename T >  | 
| void  | set (const std::string &property, const T &value) | 
|   | set a property of the element to the given value and perform standard conversions if necessary.  
  | 
|   | 
| template<typename T >  | 
| T  | get (const std::string &property) | 
|   | query a property of the element and perform standard conversions if necessary.  
  | 
|   | 
| void  | multi_set (const std::string &property_assignments, bool report_error=true) | 
|   | set several properties  
  | 
|   | 
| bool  | is_property (const std::string &property_name, std::string *type_name=0) | 
|   | check if the given name specifies a property.  
  | 
|   | 
| void *  | find_member_ptr (const std::string &property_name, std::string *type_name=0) | 
|   | find a member pointer by name.  
  | 
|   | 
| int  | get_ref_count () const | 
|   | read access to current count  
  | 
|   | 
|   | drawable () | 
|   | default construction  
  | 
|   | 
| void  | hide () | 
|   | hide the drawable  
  | 
|   | 
| void  | show () | 
|   | show the drawable  
  | 
|   | 
| bool  | is_visible () const | 
|   | check whether the drawable is visible  
  | 
|   | 
| context *  | get_context () const | 
|   | access the current context. The context will be available latestly in the init method but not in the contructor.  
  | 
|   | 
| void  | set_context (context *_ctx) | 
|   | set the current focus context, this should only be called by the context itself  
  | 
|   | 
| view *  | find_view_as_node (size_t view_idx=0) const | 
|   | convenience function to find the view control in the current hierarchy  
  | 
|   | 
| bool  | get_world_location (int x, int y, const view &V, dvec3 &world_location, double *window_z_ptr=0) const | 
|   | use given view together with depth buffer of context in order to compute the world location of the point at mouse pointer location (x,y)  
  | 
|   | 
| void  | post_redraw () | 
|   | posts a redraw event to the current context if one is available  
  | 
|   | 
| void  | force_redraw () | 
|   | forces a redraw right now. This cannot be called from init, init_frame, draw, finish_draw, finish_frame and clear  
  | 
|   | 
| virtual void  | resize (unsigned int w, unsigned int h) | 
|   | callback to announce resizing of the output window  
  | 
|   | 
| virtual void  | finish_frame (context &) | 
|   | this method is called in one pass over all drawables after drawing  
  | 
|   | 
| virtual void  | after_finish (context &) | 
|   | this method is called in one pass over all drawables after finish frame  
  | 
|   | 
|   | traverse_policy (int _policy=TP_ALL+TP_STOP_ON_SUCCESS, bool _active=true, int _focus=-1) | 
|   | construct default traverse policy that visits everything  
  | 
|   | 
| int  | get_policy () const | 
|   | return the policy without the stop on success flag  
  | 
|   | 
| bool  | stop_on_success () const | 
|   | return whether to stop on success  
  | 
|   | 
| bool  | stop_on_failure () const | 
|   | return whether to stop on failure  
  | 
|   | 
| void  | set_policy (int _policy) | 
|   | set a new policy, always add stop on success flag if needed  
  | 
|   | 
| int  | get_focused_child () const | 
|   | return the focused child or -1 if none is focused  
  | 
|   | 
| void  | set_focused_child (int _focused_child) | 
|   | set the focused child  
  | 
|   | 
| bool  | get_active () const | 
|   | return whether the current node is active  
  | 
|   | 
| void  | set_active (bool _active) | 
|   | set the active flag of the current node  
  | 
|   | 
  Public Member Functions inherited from cgv::gui::event_handler | 
|   | event_handler () | 
|   | default construction  
  | 
|   | 
| bool  | grab_focus () | 
|   | grab the focus in all parent nodes  
  | 
|   | 
| bool  | add_key_control (const std::string &property, const std::string &options, cgv::base::group_ptr group=cgv::base::group_ptr()) | 
|   | add a key control for the given property with the given options.  
  | 
|   | 
| void  | remove_element (cgv::base::base_ptr) | 
|   | remove a single element from the gui  
  | 
|   | 
| void  | remove_all_elements () | 
|   | this method removes all elements from the gui and can be used in a method that rebuilds the complete gui  
  | 
|   | 
| cgv::base::base_ptr  | find_element (const std::string &name) | 
|   | find a gui element by name in the current group, return empty pointer if not found  
  | 
|   | 
| template<typename T >  | 
| data::ref_ptr< view< T > >  | find_view (const T &value, int *idx_ptr=0) | 
|   | find a view of a given class member  
  | 
|   | 
| template<typename T >  | 
| data::ref_ptr< control< T > >  | find_control (T &value, int *idx_ptr=0) | 
|   | find a control of a given class member  
  | 
|   | 
| control_ptr  | find_control_void (void *value_ptr, int *idx_ptr) | 
|   | access to control of untyped member pointer  
  | 
|   | 
| view_ptr  | find_view_void (void *value_ptr, int *idx_ptr) | 
|   | access to view of untyped member pointer  
  | 
|   | 
| template<typename T >  | 
| void  | set_control_property (T &value, const std::string &property_name, const std::string &property_value) | 
|   | Set the property value of all controls of a given class member.  
  | 
|   | 
| gui_group_ptr  | get_parent_group () const | 
|   | use the parent group to append to be managed elements that should be destroyed in a post_recreate_gui event  
  | 
|   | 
| view_ptr  | add_view_void (const std::string &label, const void *value_ptr, const std::string &value_type, const std::string &gui_type, const std::string &options, const std::string &align) | 
|   | add a newly created view to the group  
  | 
|   | 
| control_ptr  | add_control_void (const std::string &label, void *value_ptr, abst_control_provider *acp, const std::string &value_type, const std::string &gui_type, const std::string &options, const std::string &align, void *user_data) | 
|   | add a newly created control to the group  
  | 
|   | 
|   | provider () | 
|   | default construction  
  | 
|   | 
|   | ~provider () | 
|   | ensure to remove posted recreation callbacks  
  | 
|   | 
| virtual std::string  | get_gui_name () const | 
|   | Derive a name for this instance that can be used in the gui as heading.  
  | 
|   | 
| virtual std::string  | get_parent_type () const | 
|   | Returns the group type that should be used by the class embedding the gui of the provider.  
  | 
|   | 
| virtual bool  | ensure_selected_in_tab_group_parent () | 
|   | ensure that my UI is selected in the parent group in case this is a tab group, otherwise return false  
  | 
|   | 
| virtual void  | update_member (void *member_ptr) | 
|   | call this to update all views and controls of a member  
  | 
|   | 
| virtual void  | update_all_members () | 
|   | call this to update all views and controls of all member  
  | 
|   | 
| virtual std::string  | get_menu_path () const | 
|   | return a path in the main menu to select the gui  
  | 
|   | 
| virtual shortcut  | get_shortcut () const | 
|   | return a shortcut to activate the gui without menu navigation  
  | 
|   | 
| virtual void  | recreate_gui () | 
|   | Recreate the gui of this instance right now.  
  | 
|   | 
| virtual void  | post_recreate_gui () | 
|   | delayed recreation of gui  
  | 
|   | 
| void  | align (const std::string &_align) | 
|   | send pure alignment information  
  | 
|   | 
| std::string  | concat_enum_def (const std::vector< std::string > &names, const std::string &additional_first_name="", const std::string &additional_last_name="") | 
|   | add a new group to the given parent group, not supported yet  
  | 
|   | 
| gui_group_ptr  | add_object_gui (cgv::base::base_ptr object, const std::string &label, const std::string &group_type, const std::string &options, const std::string &align) | 
|   | 
| void  | integrate_object_gui (cgv::base::base_ptr object) | 
|   | call this in create_gui() function to integrate gui of another provider object by setting the parent group and parent provider of the other object  
  | 
|   | 
| void  | inline_object_gui (cgv::base::base_ptr object) | 
|   | integrate (if not explicitly done before) and inline the gui of another object that must be derived from provider  
  | 
|   | 
| gui_group_ptr  | add_group (const std::string &label, const std::string &group_type, const std::string &options="", const std::string &align="\n") | 
|   | add a newly created subgroup to the group  
  | 
|   | 
| cgv::base::base_ptr  | add_decorator (const std::string &label, const std::string &decorator_type, const std::string &options="", const std::string &align="\n") | 
|   | add a newly created decorator to the group  
  | 
|   | 
| button_ptr  | add_button (const std::string &label, const std::string &options="", const std::string &align="\n") | 
|   | use the current gui driver to append a new button with the given label  
  | 
|   | 
| template<typename T >  | 
| data::ref_ptr< view< T > >  | add_view (const std::string &label, const T &value, const std::string &gui_type="", const std::string &options="", const std::string &align="\n") | 
|   | use this to add a new view to the gui with a given value type, gui type and init options  
  | 
|   | 
| template<typename T >  | 
| data::ref_ptr< control< T > >  | add_control (const std::string &label, T &value, const std::string &gui_type="", const std::string &options="", const std::string &align="\n") | 
|   | use this to add a new control to the gui with a given value type, gui type and init options  
  | 
|   | 
| template<typename T >  | 
| data::ref_ptr< control< T > >  | add_control (const std::string &label, control_provider< T > *provider, const std::string &gui_type="", const std::string &options="", const std::string &align="\n", void *user_data=0) | 
|   | use this to add a new control to the gui, where the control is implemented with a control provider class  
  | 
|   | 
| template<typename T >  | 
| data::ref_ptr< control< T > >  | add_member_control (cgv::base::base *base_ptr, const std::string &label, T &value, const std::string &gui_type="", const std::string &options="", const std::string &align="\n") | 
|   | add control with callback to cgv::base::on_set method on cgv::gui::control::value_change  
  | 
|   | 
| bool  | add_tree_node (const std::string &label, bool &toggle, int level, const std::string &a="\n", gui_group_ptr ggp=gui_group_ptr()) | 
|   | add a collapsable node to the gui (deprecated)  
  | 
|   | 
| template<typename T >  | 
| bool  | begin_tree_node (const std::string &label, const T &value, bool initial_visibility=false, const std::string &options="", gui_group_ptr ggp=gui_group_ptr()) | 
|   | Begin a sub tree of a tree structured gui.  
  | 
|   | 
| template<typename T >  | 
| void  | end_tree_node (const T &value) | 
|   | template specialization that allows to specify value reference plus node_instance by using the result of the function with_instance(value,idx) for the value argument finish a sub tree begun with begin_tree_node  
  
  | 
|   | 
| template<typename T >  | 
| bool  | is_tree_node_visible (const T &value) const | 
|   | return whether the sub tree attached to a value is visible  
  | 
|   | 
| template<typename T >  | 
| void  | set_tree_node_visibility (const T &value, bool is_visible) | 
|   | set the visibility status of sub tree attached to a value. This calls the post_recreate method if needed.  
  | 
|   | 
| bool  | begin_tree_node_void (const std::string &label, const void *value_ptr, int index=-1, bool initial_visibility=false, const std::string &options="", gui_group_ptr ggp=gui_group_ptr()) | 
|   | void version of the templated functions  
  | 
|   | 
| void  | end_tree_node_void (const void *value_ptr, int index=-1) | 
|   | 
| bool  | is_tree_node_visible_void (const void *value_ptr, int index) const | 
|   | 
| void  | set_tree_node_visibility_void (const void *value_ptr, int index, bool is_visible) | 
|   | 
| template<typename T >  | 
| bool  | add_gui (const std::string &label, T &value, const std::string &gui_type="", const std::string &options="") | 
|   | Add a composed gui of the given gui_type for the given value.  
  | 
|   |