|  | 
| std::string | get_type_name () const override | 
|  | overload to return the type name of this object. By default the type interface is queried over get_type. 
 | 
|  | 
| void | clear (cgv::render::context &ctx) override | 
|  | clear all objects living in the context like textures or display lists 
 | 
|  | 
| void | handle_member_change (const cgv::utils::pointer_test &m) override | 
|  | implement to handle member changes 
 | 
|  | 
| bool | init (cgv::render::context &ctx) override | 
|  | this method is called after creation or recreation of the context, return whether all necessary functionality is supported 
 | 
|  | 
| void | init_frame (cgv::render::context &ctx) override | 
|  | this method is called in one pass over all drawables before the draw method 
 | 
|  | 
| void | draw_content (cgv::render::context &ctx) override | 
|  | 
| void | set_color_map (cgv::render::context &ctx, const cgv::render::color_map &cm) | 
|  | 
| void | set_width (size_t w) | 
|  | 
| void | set_height (size_t h) | 
|  | 
| void | set_title (const std::string &t) | 
|  | 
| OrientationOption | get_orientation () const | 
|  | 
| void | set_orientation (OrientationOption orientation) | 
|  | 
| AlignmentOption | get_label_alignment () const | 
|  | 
| void | set_label_alignment (AlignmentOption alignment) | 
|  | 
| vec2 | get_range () const | 
|  | 
| void | set_range (vec2 r) | 
|  | 
| vec2 | get_display_range () const | 
|  | 
| void | set_display_range (vec2 r) | 
|  | 
| void | set_invert_color (bool flag) | 
|  | 
| unsigned | get_num_ticks () | 
|  | 
| void | set_num_ticks (unsigned n) | 
|  | 
| void | set_label_precision (unsigned p) | 
|  | 
| void | set_label_auto_precision (bool enabled) | 
|  | 
| void | set_label_prune_trailing_zeros (bool enabled) | 
|  | 
| void | set_label_integer_mode (bool enabled) | 
|  | 
| void | set_show_opacity (bool enabled) | 
|  | 
|  | themed_canvas_overlay () | 
|  | creates an overlay in the bottom left corner with zero size using a canvas for 2d drawing 
 | 
|  | 
| bool | init (cgv::render::context &ctx) override | 
|  | this method is called after creation or recreation of the context, return whether all necessary functionality is supported 
 | 
|  | 
| virtual void | handle_theme_change (const cgv::gui::theme_info &theme) override | 
|  | override in your class to handle theme changes 
 | 
|  | 
| bool | get_background_visible () const | 
|  | 
| void | set_background_visible (bool flag) | 
|  | 
|  | canvas_overlay () | 
|  | creates an overlay in the bottom left corner with zero size using a canvas for 2d drawing 
 | 
|  | 
| virtual void | on_set (void *member_ptr) override | 
|  | default implementation of that calls handle_member_change and afterwards upates the member in the gui and post damage to the canvas overlay 
 | 
|  | 
| void | after_finish (cgv::render::context &) override | 
|  | draw the content of the canvas overlay 
 | 
|  | 
| void | post_damage (bool redraw=true) | 
|  | 
| ivec2 | get_local_mouse_pos (ivec2 mouse_pos) const override | 
|  | return the mouse position local to the container of this overlay taking the canvas origin into account 
 | 
|  | 
| bool | is_hit (const ivec2 &mouse_pos) const override | 
|  | Test if the mouse pointer is hovering over this overlay and returns true if this is the case. 
 | 
|  | 
| virtual bool | self_reflect (cgv::reflect::reflection_handler &_rh) | 
|  | overload to reflect members of derived classes 
 | 
|  | 
| virtual void | stream_help (std::ostream &os) | 
|  | overload to stream help information to the given output stream 
 | 
|  | 
| virtual bool | handle (cgv::gui::event &e) | 
|  | handle incomming events; calls handle_key_events or handle_mouse_events depending on the event type; mouse events will only be handled if the mouse is over the overlay rectangle 
 | 
|  | 
| virtual bool | handle_key_event (cgv::gui::key_event &e) | 
|  | overload this method to handle key events 
 | 
|  | 
| virtual bool | handle_mouse_event (cgv::gui::mouse_event &e, cgv::ivec2 local_mouse_pos) | 
|  | overload this method to handle mouse events; local_mouse_pos is the mouse position in the local coordinate space of the overlay rectangle 
 | 
|  | 
| bool | blocks_events () const | 
|  | return whether this overlay blocks events, i.e. does not pass them to the next event handler 
 | 
|  | 
| void | blocks_events (bool flag) | 
|  | set whether the overlay blocks events 
 | 
|  | 
| ivec2 | get_viewport_size () const | 
|  | return the current viewport size 
 | 
|  | 
| cgv::g2d::irect | get_rectangle () const | 
|  | return the current rectangle area (in screen coordinates) of the overlay taking layout into account 
 | 
|  | 
| cgv::g2d::irect | get_local_rectangle () const | 
|  | return the current rectangle area of the overlay in local space, i.e. with position set to zero 
 | 
|  | 
| AlignmentOption | get_horizontal_alignment () const | 
|  | get the horizontal alignment 
 | 
|  | 
| AlignmentOption | get_vertical_alignment () const | 
|  | get the vertical alignment 
 | 
|  | 
| vec2 | get_percentual_offset () const | 
|  | get the percentual alignment offset (only valid if get_horizontal_alignment() or get_vertical_alignment() returns AlignmentOption::AO_PERCENTUAL) 
 | 
|  | 
| void | set_alignment (AlignmentOption horizontal, AlignmentOption vertical, vec2 percentual_offset=vec2(-1.0f)) | 
|  | set the alignment options 
 | 
|  | 
| StretchOption | get_stretch () const | 
|  | get the stretch 
 | 
|  | 
| vec2 | get_percentual_size () const | 
|  | get the percentual stretch (only valid if get_stretch() returns StretchOption::SO_PERCENTUAL) 
 | 
|  | 
| void | set_stretch (StretchOption stretch, vec2 percentual_size=vec2(-1.0f)) | 
|  | set the stretch option 
 | 
|  | 
| ivec2 | get_margin () const | 
|  | return the margin as set in the layout parameters 
 | 
|  | 
| void | set_margin (const ivec2 &margin) | 
|  | set the overlay margin 
 | 
|  | 
| void | set_size (const ivec2 &size) | 
|  | set the default size of the overlay before stretch gets applied 
 | 
|  | 
| void | set_visibility (bool visible) | 
|  | set the visibility of the overlay 
 | 
|  | 
| void | toggle_visibility () | 
|  | toggle the visibility of the overlay 
 | 
|  | 
| bool | ensure_viewport (cgv::render::context &ctx) | 
|  | Check whether the viewport size has changed since the last call to this method. 
 | 
|  | 
| bool | ensure_layout (cgv::render::context &ctx) | 
|  | 
| bool | begin_overlay_gui () | 
|  | begins a tree node if create default tree node is set in the gui options; automatically creates the layout gui 
 | 
|  | 
| void | end_overlay_gui () | 
|  | ends the tree node of the overlay gui 
 | 
|  | 
| void | create_layout_gui () | 
|  | provides a default gui implementation for private overlay layout members 
 | 
|  | 
| void | create_gui () | 
|  | Creates a tree node containing the overlay layout options and the gui as specified by the derived overlay class. 
 | 
|  | 
|  | 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 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 | draw (context &) | 
|  | overload to draw the content of this drawable 
 | 
|  | 
| virtual void | finish_draw (context &) | 
|  | this method is called when the current drawable is left in a tree traversal that calls the draw method 
 | 
|  | 
| virtual void | finish_frame (context &) | 
|  | this method is called in one pass over all drawables after drawing 
 | 
|  | 
|  | 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 
 | 
|  | 
| 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. 
 | 
|  | 
|  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. 
 | 
|  |