format 66
"treemultictrl" // bbtk::kernel::src::ThirdParty::wx::treemultictrl
  revision 1
  modified_by 2 "davila"
  // class settings
  //class diagram settings
  draw_all_relations default hide_attributes default hide_operations default show_members_full_definition default show_members_visibility default show_members_stereotype default show_members_multiplicity default show_members_initialization default show_attribute_modifiers default member_max_width 0 show_parameter_dir default show_parameter_name default package_name_in_tab default class_drawing_mode default drawing_language default show_context_mode default auto_label_position default show_relation_modifiers default show_infonote default shadow default show_stereotype_properties default
  //use case diagram settings
  package_name_in_tab default show_context default auto_label_position default draw_all_relations default class_drawing_mode default shadow default show_stereotype_properties default
  //sequence diagram settings
  show_full_operations_definition default write_horizontally default class_drawing_mode default drawing_language default draw_all_relations default shadow default show_stereotype_properties default
  //collaboration diagram settings
  show_full_operations_definition default show_hierarchical_rank default write_horizontally default drawing_language default package_name_in_tab default show_context default draw_all_relations default shadow default show_stereotype_properties default
  //object diagram settings
   write_horizontally default package_name_in_tab default show_context default auto_label_position default draw_all_relations default shadow default show_stereotype_properties default
  //component diagram settings
  package_name_in_tab default show_context default auto_label_position default draw_all_relations default shadow default
  draw_component_as_icon default show_component_req_prov default show_component_rea default show_stereotype_properties default
  //deployment diagram settings
  package_name_in_tab default show_context default write_horizontally default auto_label_position default draw_all_relations default shadow default
  draw_component_as_icon default show_component_req_prov default show_component_rea default show_stereotype_properties default
  //state diagram settings
  package_name_in_tab default show_context default auto_label_position default write_trans_label_horizontally default show_trans_definition default draw_all_relations default shadow default
  show_activities default region_horizontally default drawing_language default show_stereotype_properties default
  //activity diagram settings
  package_name_in_tab default show_context default show_opaque_action_definition default auto_label_position default write_flow_label_horizontally default draw_all_relations default shadow default
  show_infonote default drawing_language default show_stereotype_properties default
  
  classview 128258 "treemultictrl"
    //class diagram settings
    draw_all_relations default hide_attributes default hide_operations default show_members_full_definition default show_members_visibility default show_members_stereotype default show_members_multiplicity default show_members_initialization default show_attribute_modifiers default member_max_width 0 show_parameter_dir default show_parameter_name default package_name_in_tab default class_drawing_mode default drawing_language default show_context_mode default auto_label_position default show_relation_modifiers default show_infonote default shadow default show_stereotype_properties default
    //collaboration diagram settings
    show_full_operations_definition default show_hierarchical_rank default write_horizontally default drawing_language default package_name_in_tab default show_context default draw_all_relations default shadow default show_stereotype_properties default
    //object diagram settings
     write_horizontally default package_name_in_tab default show_context default auto_label_position default draw_all_relations default shadow default show_stereotype_properties default
    //sequence diagram settings
    show_full_operations_definition default write_horizontally default class_drawing_mode default drawing_language default draw_all_relations default shadow default show_stereotype_properties default
    //state diagram settings
    package_name_in_tab default show_context default auto_label_position default write_trans_label_horizontally default show_trans_definition default draw_all_relations default shadow default
    show_activities default region_horizontally default drawing_language default show_stereotype_properties default
    //class settings
    //activity diagram settings
    package_name_in_tab default show_context default show_opaque_action_definition default auto_label_position default write_flow_label_horizontally default draw_all_relations default shadow default
    show_infonote default drawing_language default show_stereotype_properties default
    class 139778 "TreeMultiItemBase"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      operation 161026 "TreeMultiItemBase"
	preserve_cpp_body_indent protected explicit_return_type ""
	nparams 1
	  param inout name "parent" type class_ref 139906 // TreeMultiItemNode
	cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}${)}${volatile}${throw};
"
	cpp_def "//* TreeMultiItemBase

//  * This class is the node of the whole tree. All the other classes in the

//  * tree descend from this node. It contains the type of the class without
//  * using RTTI. NOTE: this class cannot be constructed directly
//  

${comment}${inline}${class}::${name}${(}${t0} * ${p0}${)}
	: _excluded(false)

	, _x(0)
	, _y(0)
        , _width(0)

        , _height(0)

        , _parent(parent)

        , m_Selected(false)

#if(CHECKBOXVIEW)

        , _checkbox(false)

        , _checkboxState(0)

#endif
${throw}{
${body}}
"
	
	
	
	
      end

      attribute 139778 "_name"
	protected explicit_type "wxString"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 139906 "_excluded"
	protected explicit_type "bool"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 140034 "_type"
	protected explicit_type "int"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 140162 "_checkbox"
	protected explicit_type "bool"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 140290 "_checkboxState"
	protected explicit_type "int"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      operation 161154 "~TreeMultiItemBase"
	preserve_cpp_body_indent cpp_virtual public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw};
"
	cpp_def "${comment}${inline}${class}::${name}${(}${)}${throw}{
${body}}
"
	
	
	
	
      end

      operation 161282 "GetType"
	const cpp_inline public explicit_return_type "int"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return _type; };
"
	
	
	
	
	comment " type of tree item"
      end

      operation 161410 "GetParent"
	const cpp_inline public return_type class_ref 139906 // TreeMultiItemNode
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} { return _parent; };
"
	
	
	
	
      end

      operation 161538 "GetName"
	const cpp_inline public explicit_return_type "wxString"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
                return _name;
        };
"
	
	
	
	
	comment "* Get name of this node "
      end

      operation 161666 "SetName"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "NewName" explicit_type "wxString"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
    this->_name = NewName;
  };
"
	
	
	
	
	comment "* Set name of the item "
      end

      operation 161794 "IsTreeMultiItemRoot"
	const cpp_virtual cpp_inline public return_type class_ref 140034 // TreeMultiItemRoot
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
		return 0;
	};
"
	
	
	
	
	comment "* returns the instance pointer if the current node is
        a TreeMultiItemRoot, and NULL when it's not.
	"
      end

      operation 161922 "IsTreeMultiItemWindow"
	const cpp_virtual cpp_inline public return_type class_ref 140162 // TreeMultiItemWindow
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
		return 0;
	};
"
	
	
	
	
	comment "* returns the instance pointer if the current node is
        a TreeMultiItemWindow, and NULL when it's not.
	"
      end

      operation 162050 "IsTreeMultiItemNode"
	const cpp_virtual cpp_inline public return_type class_ref 139906 // TreeMultiItemNode
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
		return 0;
	};
"
	
	
	
	
	comment "* returns the instance pointer if the current node is
        a TreeMultiItemNode, and NULL when it's not.
	"
      end

      operation 162178 "SetExcluded"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "excluded" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
		_excluded = excluded;
	};
"
	
	
	
	
	comment "* Sets or resets the excluded flag. When excluded node is not visible "
      end

      operation 162306 "SetX"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "x" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
		_x = x;
	};
"
	
	
	
	
	comment "* Get / Set routine for X "
      end

      operation 162434 "GetX"
	const cpp_inline public explicit_return_type "int"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
		return _x;
	};
"
	
	
	
	
      end

      operation 162562 "SetY"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "y" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
		_y = y;
	};
"
	
	
	
	
	comment "* Get / Set routine for Y "
      end

      operation 162690 "GetY"
	const cpp_inline public explicit_return_type "int"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
		return _y;
	};
"
	
	
	
	
      end

      operation 162818 "SetHeight"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "height" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
		_height = height;
	};
"
	
	
	
	
	comment "* Get / Set routine for height "
      end

      operation 162946 "GetHeight"
	const cpp_inline public explicit_return_type "int"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
		return _height;
	};
"
	
	
	
	
      end

      operation 163074 "SetWidth"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "width" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
		_width = width;
	};
"
	
	
	
	
	comment "* Get / Set routine for width "
      end

      operation 163202 "GetWidth"
	const cpp_inline public explicit_return_type "int"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
		return _width;
	};
"
	
	
	
	
      end

      operation 163330 "IsVisible"
	preserve_cpp_body_indent public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Returns true when this item is drawn somewhere in the
	    tree. Whenever a parent of this node is collapsed, it
	    is not visible and it is not necessary to perform i.e.
	    redraw actions. 
		
		It also returns false when this node is excluded from the
		tree. 
		
		\\sa wxTreeMultiCtrl::Exclude(), wxTreeMultiCtrl::Include())
	"
      end

      operation 163458 "IsExcluded"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
                return _excluded;
        };
"
	
	
	
	
	comment " Returns if this node is excluded from the tree. If this item
	   is a Node, then all kids are excluded as well "
      end

      operation 163586 "IsSelected"
	const cpp_inline public explicit_return_type "bool"
	nparams 1
	  param in name "" explicit_type "void"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
    return this->m_Selected;
  };
"
	
	
	
	
	comment " item selection status handling
* checks if the item is selected "
      end

      operation 163714 "Select"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "" explicit_type "void"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
    this->m_Selected = true;
  };
"
	
	
	
	
	comment "* mark the current item as selected "
      end

      operation 163842 "ToggleSelection"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "" explicit_type "void"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
    this->m_Selected = !(this->m_Selected);
  };
"
	
	
	
	
	comment "* toggle the selection status "
      end

      operation 163970 "Unselect"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "" explicit_type "void"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
    this->m_Selected = false;
  };
"
	
	
	
	
	comment "* unmark the item "
      end

      operation 164098 "SetCheckbox"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "value" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
		_checkbox = value;
	};
"
	
	
	
	
	comment "* Sets checkbox or not. This does not influence the state of the checkbox "
      end

      operation 164226 "GetCheckbox"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
		return _checkbox;
	};
"
	
	
	
	
	comment "* Returns current state of the checkbox view "
      end

      operation 164354 "SetCheckboxState"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "state" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
		wxCHECK2(state < 3 && state >= 0, return);
		_checkboxState = state;
	};
"
	
	
	
	
	comment "* Sets checkbox state. If 0 it's unchecked, 1 = checked and 2 = tristate "
      end

      operation 164482 "GetCheckboxState"
	const cpp_inline public explicit_return_type "int"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
		return _checkboxState;
	};
"
	
	
	
	
	comment "* Returns current state of checkbox "
      end

      classrelation 135170 // _parent (<unidirectional association>)
	relation 135170 --->
	  a role_name "_parent" private
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
"
	    classrelation_ref 135170 // _parent (<unidirectional association>)
	  b parent class_ref 139906 // TreeMultiItemNode
      end

      attribute 140418 "m_Selected"
	private explicit_type "bool"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end
    end

    class 139906 "TreeMultiItemNode"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      classrelation 135298 // <generalisation>
	relation 135298 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 135298 // <generalisation>
	  b parent class_ref 139778 // TreeMultiItemBase
      end

      attribute 140546 "_items"
	private explicit_type "TreeMultiItemBaseArray"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 140674 "_caption"
	private explicit_type "wxString"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 140802 "_nodeExpanded"
	private explicit_type "bool"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 140930 "m_Attributes"
	private explicit_type "wxTreeItemAttr"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      operation 164610 "TreeMultiItemNode"
	preserve_cpp_body_indent public explicit_return_type ""
	nparams 3
	  param inout name "parent" type class_ref 139906 // TreeMultiItemNode
	  param in name "caption" explicit_type "wxString"
	    defaultvalue "wxEmptyString"
	  param in name "name" explicit_type "wxString"
	    defaultvalue "wxEmptyString"
	cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}, const ${t1} & ${p1}${v1}, const ${t2} & ${p2}${v2}${)}${volatile}${throw};
"
	cpp_def "//* TreeMultiItemNode
//  * This class is a container holder for multiple TreeMultiItemBase classes.
//  * Since both a TreeMultiItemNode and a TreeMultiItemWindow are a descendant
//  * from a TreeMultiItemBase class, it can hold multiple of these.
//  * In the case of a directory tree structure, it can hold multiple
//  * directories, and leafs (files).
//  
// default constructor for container composite

${comment}${inline}${class}::${name}${(}${t0} * ${p0}, const ${t1} & ${p1}, const ${t2} & ${p2}${)}
	: TreeMultiItemBase(parent)
	, _caption(caption)
	, _nodeExpanded(true)

${throw}{
${body}}
"
	
	
	
	
      end

      operation 164738 "~TreeMultiItemNode"
	preserve_cpp_body_indent cpp_virtual public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw};
"
	cpp_def "//------------------------------------------------------------

${comment}${inline}${class}::${name}${(}${)}${throw}{
${body}}
"
	
	
	
	
      end

      operation 164866 "IsTreeMultiItemNode"
	const cpp_virtual cpp_inline public return_type class_ref 139906 // TreeMultiItemNode
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
		return (TreeMultiItemNode *)this;
	};
"
	
	
	
	
	comment " isClass method"
      end

      operation 164994 "AddNode"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 1
	  param inout name "node" type class_ref 139778 // TreeMultiItemBase
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "//------------------------------------------------------------

${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment " add methods
"
      end

      operation 165122 "InsertNode"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 2
	  param inout name "NodePtr" type class_ref 139778 // TreeMultiItemBase
	  param in name "Position" explicit_type "size_t"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 165250 "Clear"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "//------------------------------------------------------------

${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment " delete methods
"
      end

      operation 165378 "DeleteNode"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 1
	  param inout name "node" type class_ref 139778 // TreeMultiItemBase
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "//------------------------------------------------------------


${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 165506 "DeleteNode"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 1
	  param in name "index" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "//------------------------------------------------------------

${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 165634 "RemoveNode"
	preserve_cpp_body_indent public return_type class_ref 139778 // TreeMultiItemBase
	nparams 1
	  param inout name "node" type class_ref 139778 // TreeMultiItemBase
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "//------------------------------------------------------------

${comment}${inline}${type} * ${class}::${name}${(}${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 165762 "RemoveNode"
	preserve_cpp_body_indent public return_type class_ref 139778 // TreeMultiItemBase
	nparams 1
	  param in name "index" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "//------------------------------------------------------------

${comment}${inline}${type} * ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 165890 "GetNodeCount"
	preserve_cpp_body_indent const public explicit_return_type "int"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "//------------------------------------------------------------

${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment " get methods"
      end

      operation 166018 "GetNode"
	preserve_cpp_body_indent const public return_type class_ref 139778 // TreeMultiItemBase
	nparams 1
	  param in name "index" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "//------------------------------------------------------------

${comment}${inline}${type} * ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 166146 "Index"
	preserve_cpp_body_indent const public explicit_return_type "int"
	nparams 2
	  param inout name "node" type class_ref 139778 // TreeMultiItemBase
	  param in name "searchFromEnd" explicit_type "bool"
	    defaultvalue "false"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "//------------------------------------------------------------

${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 166274 "GetNodeNext"
	preserve_cpp_body_indent const public return_type class_ref 139778 // TreeMultiItemBase
	nparams 1
	  param inout name "cookie" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "//------------------------------------------------------------

${comment}${inline}${type} * ${class}::${name}${(}${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 166402 "First"
	preserve_cpp_body_indent const public return_type class_ref 139778 // TreeMultiItemBase
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "//------------------------------------------------------------


${comment}${inline}${type} * ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 166530 "Last"
	preserve_cpp_body_indent const public return_type class_ref 139778 // TreeMultiItemBase
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// TreeMultiItemNode::First() const 

${comment}${inline}${type} * ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 166658 "Fold"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "expand" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
		if(_nodeExpanded != expand)
			_nodeExpanded = expand;
	};
"
	
	
	
	
	comment "* Fold function sets or clears the expanded flag. Note when excluded from drawing, this

	    will have no effect on redraw "
      end

      operation 166786 "GetCaption"
	const cpp_inline public explicit_return_type "wxString"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} {
		return _caption;
	};
"
	
	
	
	
	comment "* Return caption "
      end

      operation 166914 "IsExpanded"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
		return _nodeExpanded;
	};
"
	
	
	
	
	comment "* Returns true if the node is expanded. Subnodes can still be collapsed though "
      end
    end

    class 140034 "TreeMultiItemRoot"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "* This class is the root class. It can hold many of the TreeMultiItemWindow and

 * TreeMultiItemNode classes.

 "
      classrelation 135426 // <generalisation>
	relation 135426 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 135426 // <generalisation>
	  b parent class_ref 139906 // TreeMultiItemNode
      end

      operation 167042 "TreeMultiItemRoot"
	preserve_cpp_body_indent public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw};
"
	cpp_def "//* TreeMultiItemRoot

// * This class is the class you use to create a tree. It contains all the

// * public methods from a TreeMultiItemNode, but you can add more to it 

// * because it is the root. A typical addition is the load entry for a 

// * directory, or other type of enumeration. You could store the base path

// * of a relative tree in this class.

// 

${comment}${inline}${class}::${name}${(}${)}

	: TreeMultiItemNode(0, _T(\"\"), _T(\"\"))

${throw}{
${body}}
"
	
	
	
	
      end

      operation 167170 "~TreeMultiItemRoot"
	preserve_cpp_body_indent cpp_virtual public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw};
"
	cpp_def "${comment}${inline}${class}::${name}${(}${)}${throw}{
${body}}
"
	
	
	
	
      end

      operation 167298 "IsTreeMultiItemRoot"
	const cpp_virtual cpp_inline public return_type class_ref 140034 // TreeMultiItemRoot
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {

		return (TreeMultiItemRoot *)this;

	};
"
	
	
	
	
	comment " IsClass method
"
      end
    end

    class 140162 "TreeMultiItemWindow"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      classrelation 135554 // <generalisation>
	relation 135554 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 135554 // <generalisation>
	  b parent class_ref 139778 // TreeMultiItemBase
      end

      classrelation 135682 // _window (<unidirectional association>)
	relation 135682 --->
	  a role_name "_window" private
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
"
	    classrelation_ref 135682 // _window (<unidirectional association>)
	  b parent class_ref 136322 // wxWindow
      end

      attribute 141058 "_span"
	private explicit_type "bool"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      operation 167426 "TreeMultiItemWindow"
	preserve_cpp_body_indent public explicit_return_type ""
	nparams 2
	  param inout name "parent" type class_ref 139906 // TreeMultiItemNode
	  param in name "name" explicit_type "wxString"
	    defaultvalue "wxEmptyString"
	cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${volatile}${throw};
"
	cpp_def "//* TreeMultiItemWindow

//  *	This class is a possible end node for the tree. If you want multiple

//  *	types of end-nodes you should copy this file and adjust it with a 

//  *	different class name.

//  

${comment}${inline}${class}::${name}${(}${t0} * ${p0}, const ${t1} & ${p1}${)}

	:  TreeMultiItemBase(parent)

	, _window(0)

	, _topSpacing(0)

	, _frontSpacing(0)

	, _span(false)

${throw}{
${body}}
"
	
	
	
	
      end

      operation 167554 "~TreeMultiItemWindow"
	preserve_cpp_body_indent cpp_virtual public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw};
"
	cpp_def "${comment}${inline}${class}::${name}${(}${)}${throw}{
${body}}
"
	
	
	
	
      end

      operation 167682 "IsTreeMultiItemWindow"
	const cpp_virtual cpp_inline public return_type class_ref 140162 // TreeMultiItemWindow
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {

		return (TreeMultiItemWindow *)this;

	};
"
	
	
	
	
	comment " IsClass method
"
      end

      operation 167810 "AssignWindow"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 1
	  param inout name "wnd" type class_ref 136322 // wxWindow
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Assigns the given window to this TreeMultiItemWindow, and also destroys the 

		present window. If the assigned window is 0, this item is not drawn

		and removed from the tree visually "
      end

      operation 167938 "GetWindow"
	cpp_inline public return_type class_ref 136322 // wxWindow
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {

		return _window;

	};
"
	
	
	
	
	comment "* Get window method "
      end

      operation 168066 "SetFrontSpacing"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "frontSpacing" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {

		_frontSpacing = frontSpacing;

	};
"
	
	
	
	
	comment " Sets front spacing "
      end

      operation 168194 "GetFrontSpacing"
	const cpp_inline public explicit_return_type "int"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {

		return _frontSpacing;

	};
"
	
	
	
	
	comment " Gets front spacing "
      end

      operation 168322 "SetTopSpacing"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "topSpacing" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {

		_topSpacing = topSpacing;

	};
"
	
	
	
	
	comment " Sets top spacing "
      end

      operation 168450 "GetTopSpacing"
	const cpp_inline public explicit_return_type "int"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {

		return _topSpacing;

	};
"
	
	
	
	
	comment " Gets top spacing "
      end

      operation 168578 "SetHorizontalSpan"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "span" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {

		_span = span;

	};
"
	
	
	
	
	comment " Sets horizontal span, meaning when this is set the window

	   attached may be resized horizontally when the window is resized "
      end

      operation 168706 "GetHorizontalSpan"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {

		return _span;

	};
"
	
	
	
	
	comment " Sets horizontal span, meaning when this is set the window

	   attached may be resized horizontally when the window is resized "
      end

      operation 168834 "SetCheckboxState"
	preserve_cpp_body_indent cpp_virtual public explicit_return_type "void"
	nparams 1
	  param in name "state" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Inherited from base, to enable or disable window "
      end
    end

    class 140290 "anonymous1"
      visibility package stereotype "enum"
      cpp_decl "${comment}enum  {
${items}
};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "* \\defgroup hitflags wxTreeMultiCtrl HitTest flags
    @{
"
      attribute 141186 "wxTMC_HITTEST_GUTTER"
	public type class_ref 140290 // anonymous1
	init_value "= 1"
	cpp_decl "  ${name}${value},${comment}"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 141314 "wxTMC_HITTEST_WINDOW"
	public type class_ref 140290 // anonymous1
	cpp_decl "  ${name}${value},${comment}"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 141442 "wxTMC_HITTEST_CAPTION"
	public type class_ref 140290 // anonymous1
	cpp_decl "  ${name}${value},${comment}"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 141570 "wxTMC_HITTEST_CHECKBOX"
	public type class_ref 140290 // anonymous1
	cpp_decl "  ${name}${value},${comment}"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end
    end

    class 140418 "wxTreeMultiItem"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "/ wxCoord was found in the gutter of the node (in front of the [+])
/ wxCoord was found inside a window, or behind it, on a Window node
/ wxCoord was found on a caption of a Node or Root item
/ wxCoord was found on a checkbox (only when item really has a checkbox)
* @}

* @defgroup classes wxTreeMultiCtrl Classes
    These classes are all the available classes in the wxTreeMultiCtrl you should know about.
    @{

    @}

* \\class wxTreeMultiItem
    \\ingroup classes
    \\brief An intermediate class which is used to return as 'item' value for the wxTreeMultiCtrl. This class
    is comparable with wxTreeItemId.

    The wxTreeMultiItem is used to pass information to the user about the tree node in question. It can also be used point out where the
    subnodes should be added.

    For example:
    \\code

        wxTreeMultiItem item = MyMultiTreeCtrl->AddRoot(\"This is the first root\");

        // now add a node to the root
        if(item.IsOk())
            MyMultiTreeCtrl->AppendWindow(item, new wxStaticText(MyMultiTreeCtrl, -1, \"This is a static text\");


    \\endcode

    The wxTreeMultiItem comes in three internal types which are used in the wxTreeMultiCtrl. For functions such as
    wxTreeMultiCtrl::AddRoot, a Root item is returned. For functions such as wxTreeMultiCtrl::AppendWindow, a
    Window node is returned. For functions such as wxTreeMultiCtrl::AppendNode, a Node item is returned.

    \\li A Root item represents a top level item. Special operations on this item is adding multiple nodes to it from a
    top level.

    \\li A Node item represents a container item which has multiple sub items which can both be Window items, or Node items.
    A root item is a special type of Node item, so all operations which are only for Node items, are also for Root items.

    \\li A Window node represents an end node, which points to a wxWindow which represents the visual contents of this node.
    This type of node can hold any wxWindow derived class.

"
      classrelation 135810 // _item (<unidirectional association>)
	relation 135810 --->
	  a role_name "_item" private
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
"
	    classrelation_ref 135810 // _item (<unidirectional association>)
	  b parent class_ref 139778 // TreeMultiItemBase
      end

      operation 168962 "wxTreeMultiItem"
	cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw} {
        _item = 0;
    };
"
	
	
	
	
	comment "* Default declaration constructor, and should be used when declaring an item which gets assigned a new
        value by e.g. wxTreeMultiCtrl::AppendNode. "
      end

      operation 169090 "wxTreeMultiItem"
	cpp_inline public explicit_return_type ""
	nparams 1
	  param inout name "ptr" type class_ref 139778 // TreeMultiItemBase
	cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}${)}${volatile}${throw} {
        _item = ptr;
    };
"
	
	
	
	
      end

      operation 169218 "GetItem"
	const cpp_inline public return_type class_ref 139778 // TreeMultiItemBase
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {

        return _item;

    };
"
	
	
	
	
	comment " Returns the TreeMultiItemBase class. This shoult *NOT* be

 used if you don't know what you are doing! This means never use it. */
"
      end

      operation 169346 "operator ="
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        _item = item._item;

    };
"
	
	
	
	
	comment "* The copy operator. Used in assigning one wxTreeMultiItem to another, usually in returning wxTreeMultiItem
        classes from the wxTreeMultiCtrl.
    "
      end

      operation 169474 "operator =="
	const cpp_inline public explicit_return_type "bool"
	nparams 1
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {return (this->GetItem() == item.GetItem());};
"
	
	
	
	
	comment "* Equality operator. It returns true if the items are identical or if both items are invalid. "
      end

      operation 169602 "operator !="
	const cpp_inline public explicit_return_type "bool"
	nparams 1
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {return (this->GetItem() != item.GetItem());};
"
	
	
	
	
	comment "* Inequality operator. It returns true if the items are different or one of them is invalid. "
      end

      operation 169730 "GetParent"
	const cpp_inline public return_type class_ref 140418 // wxTreeMultiItem
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {

                wxCHECK(IsOk(), wxTreeMultiItem(0));

                return wxTreeMultiItem(_item->GetParent());

        };
"
	
	
	
	
	comment "* Returns the parent of the current wxTreeMultiItem. This means the wxTreeMultiNode is returned. It can

            be useful to check or clear the checkbox at this level. "
      end

      operation 169858 "IsOk"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return _item != 0;
    };
"
	
	
	
	
	comment "* Validates if the wxTreeMultiItem is a valid instance to use in the wxTreeMultiCtrl. Returns TRUE when there
        is a member value is associated with it, or FALSE when not. This value can also be checked when this class is returned from a wxTreeMultiCtrl operation. For example:

        \\code

            wxTreeMultiItem item = MyTreeMultiCtrl->FindNode(\"NAME\");
            if(item.IsOk())
            {
                // Found the node, now do something with it
            }
            else
            {
                // Sorry, not found
            }

        \\endcode

    "
      end

      operation 169986 "IsWindowItem"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        if(_item && _item->IsTreeMultiItemWindow())
            return true;
        return false;
    };
"
	
	
	
	
	comment "* Returns TRUE when the wxTreeMultiItem is a Window item. This means the item is both valid, and points to a
        window node. This means it can be used in functions that expect a Window node. If the item is invalid or a Window
        item, FALSE is returned
        \\sa wxTreeMultiCtrl::AppendWindow
    "
      end

      operation 170114 "IsNodeItem"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        if(_item && (_item->IsTreeMultiItemNode() || _item->IsTreeMultiItemRoot()))
            return true;
        return false;
    };
"
	
	
	
	
	comment "* Returns TRUE when the wxTreeMultiItem is a Node item. This means the item is both valid, and points to a
        node element (i.e. setting the caption, counting node children, etc). If the item is invalid or not a Node
        item, FALSE is returned.
        When the item is actually a root item (specialised node type), this also returns TRUE.
        \\sa wxTreeMultiCtrl::AppendNode wxTreeMultiCtrl::AddRoot
    "
      end

      operation 170242 "IsRootItem"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        if(_item && _item->IsTreeMultiItemRoot())
            return true;
        return false;
    };
"
	
	
	
	
	comment "* Returns True when the wxTreeMultiItem is a Root (top node) item. This means the item is both valid,
        and points to a root element (this item is always shown as first node in the tree). A root node is
        always visible, but can contain other collapsed children. If the item is invalid or not a Root node,
        FALSE is returned.
    "
      end

      operation 170370 "IsExpanded"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        wxCHECK(_item, false);
        TreeMultiItemNode *n = _item->IsTreeMultiItemNode();
        wxCHECK(n, false);

        return n->IsExpanded();
    };
"
	
	
	
	
	comment "* Returns TRUE if the node is expanded, else FALSE if it is collapsed. If the item is not a Root or Node
        item, an assertion failure is generated (in debug mode) or FALSE is returned (in release mode).

        \\sa wxTreeMultiCtrl::Expand, wxTreeMultiCtrl::Collapse, wxTreeMultiCtrl::CollapseAndReset
    "
      end

      operation 170498 "IsExcluded"
	cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        wxCHECK(_item, false);
        return _item->IsExcluded();

    };
"
	
	
	
	
	comment "* Returns true if this node is excluded from drawing. Please note that when this node is not visible
        due to a higher excluded parent node but not literally excluded itself, it will return false (not excluded).
        Use wxTreeMultiCtrl::GetExcludedParent() to get the node that hides this one. "
      end

      operation 170626 "IsSelected"
	const cpp_inline public explicit_return_type "bool"
	nparams 1
	  param in name "" explicit_type "void"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {

      wxCHECK(this->GetItem(),false);

      return this->GetItem()->IsSelected();

    };
"
	
	
	
	
	comment "* Returns true if the item is selected.

       Please note that currently only nodes can be selected.

   "
      end

      operation 170754 "IsVisible"
	cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        wxCHECK(_item, false);
        return _item->IsVisible();
    };
"
	
	
	
	
	comment "* Returns true if this node is visible. Please note that when this node is a child node of a collapsed

        node, it is not visible. Also if this node is a child node of an excluded node, it is also not visible.

        It does <b>NOT</b> return false when it's drawn somewhere outside of the visible area. "
      end
    end

    class 140546 "wxTreeMultiWindowInfo"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "* \\class wxTreeMultiWindowInfo

    \\ingroup classes

    \\brief This class contains information for every Window node to be added.


    This class can be used to modify the behaviour of the Window node to be added, and can be reused to pass along
    upon every wxTreeMultiCtrl::AppendWindow call. For example:

    \\code

        wxTreeMultiWindowInfo wndinfo;

        MyTreeMultiCtrl->AppendWindow(item, new wxStaticText(MyTreeMultiCtrl,
                                      -1, \"Press this button\"), \"\", wndinfo));

        // now adjust the spacing of our next window to add, by indenting
        // 4 times the indent size

        wndinfo.Indent(4);
        MyTreeMultiCtrl->AppendWindow(item, new wxButton(MyTreeMultiCtrl,
                                      -1, \"Apply\"), \"\", wndinfo);

    \\endcode

    The class is created to prevent long parameter lists in the functions. Other ways to manipulate a newly added
    Window node are;

    \\li Change top spacing of the Window node to be added
    \\li Change front spacing (indent) of the Window node
    \\li Set extra flags for this Window node

-------------------------------------------------------------------------------------------------------------------"
      attribute 141698 "_flags"
	private explicit_type "int"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 141826 "_topSpacing"
	private explicit_type "int"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 141954 "_checkState"
	private explicit_type "bool"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      operation 170882 "wxTreeMultiWindowInfo"
	cpp_inline public explicit_return_type ""
	nparams 4
	  param in name "flags" explicit_type "int"
	  param in name "frontSpacing" explicit_type "int"
	  param in name "topSpacing" explicit_type "int"
	  param in name "checkState" explicit_type "bool"
	    defaultvalue "false"
	cpp_decl "    ${comment}${inline}${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} ${p2}${v2}, ${t3} ${p3}${v3}${)}${volatile}${throw} : _flags(flags)

        , _frontSpacing(frontSpacing)

        , _frontSpacingOrg(frontSpacing)

        , _topSpacing(topSpacing)

        , _checkState(checkState)

#else

    wxTreeMultiWindowInfo(int flags, int frontSpacing, int topSpacing)

        : _flags(flags)

        , _frontSpacing(frontSpacing)

        , _frontSpacingOrg(frontSpacing)

        , _topSpacing(topSpacing)

#endif

    {

        // constructor

    };
"
	
	
	
	
      end

      operation 171010 "Indent"
	cpp_inline public explicit_return_type "int"
	nparams 1
	  param in name "num" explicit_type "int"
	    defaultvalue "1"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        if(num > 0)
            _frontSpacing += (_frontSpacingOrg * num);
        return _frontSpacing;
    };
"
	
	
	
	
	comment "* Adds indent to original front spacing and increments it with that value (quick extra indent).
        The original value of FrontSpacing (see SetFrontSpacing() gets indented by multiplying
        the 'num' factor (default = 1) times the indent value. So if the FrontSpacing was set to 10,
        and Indent(2) is called, the new indent will be 30. (10 + 2 * 10). The original FrontSpacing
        value is remembered, so calling Outdent(2) will bring it back to 10 (30 - (2*10). Calling
        SetFrontSpacing with a new value, deletes the old indent.

        \\sa Outdent, SetFrontSpacing
    "
      end

      operation 171138 "Outdent"
	cpp_inline public explicit_return_type "int"
	nparams 1
	  param in name "num" explicit_type "int"
	    defaultvalue "1"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        _frontSpacing -= (_frontSpacingOrg * num);
        if(_frontSpacing < 0)
            _frontSpacing = 0;
        return _frontSpacing;
    };
"
	
	
	
	
	comment "* Reduces indent a number of times, by subtracting 'num' times the original FrontSpacing value from
        the current FrontSpacing value (quick extra indent). Thus if the original FrontSpacing was set to
        10, and the current indent value is 40, Outdent(2) will do 40 - (2 * 10) = 20

        \\sa Indent, SetFrontSpacing
    "
      end

      operation 171266 "SetFrontSpacing"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "frontSpacing" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        _frontSpacing = frontSpacing;
        _frontSpacingOrg = frontSpacing;
    };
"
	
	
	
	
	comment "* Sets FrontSpacing value. This also resets the current indent level.  "
      end

      operation 171394 "GetFrontSpacing"
	const cpp_inline public explicit_return_type "int"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return _frontSpacing;
    };
"
	
	
	
	
	comment "* Gets front spacing. This will return the current indent level set. If Indent or Outdent is used,
        this level represents the current Indent level."
      end

      operation 171522 "SetTopSpacing"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "topSpacing" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        _topSpacing = topSpacing;
        if(_topSpacing < 0)
            _topSpacing = 0;
    };
"
	
	
	
	
	comment "* Sets top spacing. This means the number of pixels spacing between the last node and the next one to
        be added.
    "
      end

      operation 171650 "GetTopSpacing"
	const cpp_inline public explicit_return_type "int"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return _topSpacing;
    };
"
	
	
	
	
	comment " Gets top spacing currently set. "
      end

      operation 171778 "SetFlags"
	cpp_inline public explicit_return_type "int"
	nparams 1
	  param in name "flags" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        int tmp = _flags;
        _flags = flags;
        return tmp;
    };
"
	
	
	
	
	comment "* Sets the current flags set, and returns previous flags state.
        \\sa @link wndflags wxTreeMultiWindowInfo flags@endlink
    "
      end

      operation 171906 "GetFlags"
	const cpp_inline public explicit_return_type "int"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return _flags;
    };
"
	
	
	
	
	comment "* Gets the current flags set.
        \\sa @link wndflags wxTreeMultiWindowInfo flags@endlink
    "
      end

      operation 172034 "AddFlag"
	cpp_inline public explicit_return_type "int"
	nparams 1
	  param in name "flag_mask" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        int tmp = _flags;
        _flags |= flag_mask;
        return tmp;
    };
"
	
	
	
	
	comment "* Or's the given flag with the current flagset, and adds it. The
        old flag set is returned before the OR is applied.
        \\sa @link wndflags wxTreeMultiWindowInfo flags@endlink
    "
      end

      operation 172162 "RemoveFlag"
	cpp_inline public explicit_return_type "int"
	nparams 1
	  param in name "flag_mask" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        int tmp = _flags;
        _flags &= ~(flag_mask);
        return tmp;
    };
"
	
	
	
	
	comment "* And's the given flag in a negated manner and removes this flag set from
        the current flags.  The old flag set is returned.
        \\sa @link wndflags wxTreeMultiWindowInfo flags@endlink
    "
      end

      operation 172290 "SetDefaultCheckState"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "checkState" explicit_type "bool"
	    defaultvalue "true"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        _checkState = checkState;
    };
"
	
	
	
	
	comment "* Sets the default checkstate if checkboxes if SetCheckboxView is chosen. For all the
        items to be added (even captions) this checkstate is chosen. The default checkstate
        is false. <b>This needs USE_CHECKBOXVIEW set to YES, or CHECKBOXVIEW=1 during compile</b> "
      end

      operation 172418 "GetDefaultCheckState"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return _checkState;
    };
"
	
	
	
	
	comment "* Gets the default checkstate of the item. <b>This needs USE_CHECKBOXVIEW set to YES, or CHECKBOXVIEW=1 during compile</b>
        \\sa SetDefaultCheckState "
      end
    end

    class 140674 "wxTreeMultiCtrl"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "* \\class wxTreeMultiCtrl
    \\ingroup classes
    \\brief This is the visual control, which will contain all the logic for the tree mechanism.

    The wxTreeMultiCtrl is the container class which can be filled in to get the tree shaped structure in
    which the controls are displayed. The user can add / delete new nodes at runtime, expand or collapse
    nodes, perform get or set actions on the controls inside, and iterate over the items.

    A typical usage of the wxTreeCtrl is;

    \\code
    wxTreeMultiCtrl *tmc = new wxTreeMultiCtrl(this, -1);

    // add root
    wxTreeMultiItem item = tmc->AddRoot(\"This is the first root\");

    // create a wxTreeMultiWindowInfo object for indenting etc
    wxTreeMultiWindowInfo wndinfo;

    // add subitem to root
    tmc->AppendWindow(item, new wxButton(tmc, -1, \"Press this\"), \"\", wndinfo);

    // indent a few
    wndinfo.Indent(4);

    // add a new one
    tmc->AddWindow(item, new wxCheckBox(tmc, ID_MYCHECK, \"Check this!\"), \"\", wndinfo);

    // now check the value of the checkbox
    tmc->SetBooleanValue(ID_MYCHECK, true);

    \\endcode

    <b>IMPORTANT:</b> Every control added to the wxTreeMultiCtrl has to be child of the wxTreeMultiCtrl.

"
      classrelation 135938 // <generalisation>
	relation 135938 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 135938 // <generalisation>
	  b parent class_ref 140802 // typedef23
      end

      attribute 142082 "_style"
	private explicit_type "long"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 142210 "_captionHeight"
	private explicit_type "int"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 142338 "_gutterWidth"
	private explicit_type "int"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 142466 "_iconWidth"
	private explicit_type "int"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 142594 "_iconHeight"
	private explicit_type "int"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 142722 "_maxHeight"
	private explicit_type "int"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 142850 "_spacingY"
	private explicit_type "int"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 142978 "_create_called"
	private explicit_type "bool"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 143106 "_checkboxView"
	private explicit_type "bool"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 143234 "m_HilightBrush"
	private explicit_type "wxBrush"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 143362 "_captionFont"
	private explicit_type "wxFont"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 143490 "m_SelectedItems"
	private explicit_type "wxArrayTreeMultiItem"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      operation 172546 "DoFold"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 3
	  param inout name "item" type class_ref 139778 // TreeMultiItemBase
	  param in name "expand" explicit_type "bool"
	  param in name "recursive" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// wxTreeMultiCtrl::Unselect(wxTreeMultiItem const&) 

${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}, ${t2} ${p2}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Does the actual collapsing / expanding. So that Expand and Collapse aren't using the same code twice "
      end

      operation 172674 "RedrawFromNode"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 1
	  param inout name "n" type class_ref 139906 // TreeMultiItemNode
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Redraws and recalculates the nodes from the current node. It will also clear all 'dirty' flags when
        they are recalculated "
      end

      operation 172802 "RedrawFromParentNode"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 1
	  param inout name "n" type class_ref 139778 // TreeMultiItemBase
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// wxTreeMultiCtrl::InsertWindow(TreeMultiItemNode*, size_t, wxWindow*, wxString const&, wxTreeMultiWindowInfo const&, int) 

${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Redraws from parent node of this node "
      end

      operation 172930 "DrawCheckbox"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 3
	  param inout name "b" type class_ref 139778 // TreeMultiItemBase
	  param inout name "dc" explicit_type "wxDC"
	  param in name "convertScrolled" explicit_type "bool"
	    defaultvalue "false"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} & ${p1}${v1}, ${t2} ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} & ${p1}, ${t2} ${p2}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Draws checkbox belonging to this node, in the given state "
      end

      operation 173058 "RecalculateNodePositions"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Recalculate the space needed based on every node. It goes as follows.
        - A foldable node (TreeMultiItemNode) is as high as the 'Jg' y-size. This type only has a caption plus a
          picture which explains the state ([+] or [-]), the width will be the caption length
        - A window node will be as high as the y size of the window. The X size is the total length of the
          window.
        - For every child node an indent will be added to the x size.

        Only visible nodes will be recalculated. Non visible (collapsed) children will be skipped  "
      end

      operation 173186 "CalculateNodeDimensions"
	preserve_cpp_body_indent private explicit_return_type "int"
	nparams 3
	  param inout name "b" type class_ref 139778 // TreeMultiItemBase
	  param in name "currentY" explicit_type "int"
	  param in name "level" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}, ${t2} ${p2}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Recurses into the whole tree and provides every node with the proper x and y values. All non visible items
        are skipped (so when it encounters a collapsed node, it's children are not calculated). Returns the last Y "
      end

      operation 173314 "DrawNode"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 2
	  param inout name "b" type class_ref 139778 // TreeMultiItemBase
	  param inout name "dc" explicit_type "wxDC"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} & ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 173442 "SetWindowBackgroundColour"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 3
	  param inout name "wnd" type class_ref 136322 // wxWindow
	  param in name "col" explicit_type "wxColour"
	  param in name "flags" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, const ${t1} & ${p1}${v1}, ${t2} ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, const ${t1} & ${p1}, ${t2} ${p2}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Sets background colour of all the windows and subwindows in this wxWindow. This is very handy
        for wxPanel derived classes which need to be made equal to the background colour of the wxTreeMultiCtrl "
      end

      operation 173570 "ShowTreeMultiWindow"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 2
	  param inout name "window" type class_ref 140162 // TreeMultiItemWindow
	  param in name "show" explicit_type "bool"
	    defaultvalue "true"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Shows or hides the assigned window (if there is any) "
      end

      operation 173698 "UpdateAllWindowVisibility"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Goes down the tree, and if a window is not visible (thus all it's children aren't too) it will hide
        the window so it is not shown on the control "
      end

      operation 173826 "UpdateTreeMultiWindowVisibility"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 2
	  param inout name "b" type class_ref 139778 // TreeMultiItemBase
	  param in name "show" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Hides tree multi window. It this is a TreeMultiItemNode, hide all subwindows as well. "
      end

      operation 173954 "RecalculateVirtualSize"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Recalculates totally needed virtual size of the wxTreeMultiCtrl. It will scan for
        the largest window, with the biggest size, and report that back "
      end

      extra_member 128258 "using"
	
	cpp "  using wxScrolledWindow::AdjustScrollbars;" ""
	java ""
	php ""
	python ""
	idl ""
      end

      operation 174082 "AdjustScrollbars"
	preserve_cpp_body_indent cpp_virtual private explicit_return_type "void"
	nparams 2
	  param in name "x" explicit_type "int"
	  param in name "y" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 174210 "RecalculateVirtualSizeFromNode"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 3
	  param in name "node" type class_ref 139906 // TreeMultiItemNode
	  param inout name "x" explicit_type "int"
	  param inout name "y" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} * ${p0}${v0}, ${t1} & ${p1}${v1}, ${t2} & ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} * ${p0}, ${t1} & ${p1}, ${t2} & ${p2}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Recalculates and accumulates largest x and y "
      end

      operation 174338 "FindNodeByPoint"
	preserve_cpp_body_indent private return_type class_ref 139778 // TreeMultiItemBase
	nparams 3
	  param inout name "b" type class_ref 139778 // TreeMultiItemBase
	  param in name "pt" explicit_type "wxPoint"
	  param inout name "area" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} * ${p0}${v0}, const ${t1} & ${p1}${v1}, ${t2} & ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} * ${class}::${name}${(}${t0} * ${p0}, const ${t1} & ${p1}, ${t2} & ${p2}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Scans for TreeMultiItemBase node that contains x,y and in area returns a hittest constant to

        indicate what matched "
      end

      operation 174466 "FindWindowNode"
	preserve_cpp_body_indent private return_type class_ref 140418 // wxTreeMultiItem
	nparams 2
	  param inout name "wnd" type class_ref 136322 // wxWindow
	  param inout name "n" type class_ref 139906 // TreeMultiItemNode
	    defaultvalue "0"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} * ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} * ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Scans for TreeMultiItemWindow that holds the wxWindow pointer. Does not scan in panels or does

        a deep search. Reason, this function is used to advance to next TreeMultiItemWindow for focus

        on this wxScrolledWindow. If a sub window is found, it will skip other windows on that same level "
      end

      operation 174594 "FindNextVisibleWindowItem"
	preserve_cpp_body_indent private return_type class_ref 140162 // TreeMultiItemWindow
	nparams 2
	  param inout name "b" type class_ref 139778 // TreeMultiItemBase
	  param in name "index" explicit_type "int"
	    defaultvalue "-1"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} * ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Finds next visible window item in chain. If not found use FindFirstVisibleItem to start from the
        beginning "
      end

      operation 174722 "AdjustIconsDeltaY"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Adjust the centering of the bitmap icons (collapse / expand) when the caption font changes. They need to

        be centered in the middle of the font, so a bit of deltaY adjustment is needed "
      end

      operation 174850 "CalculateNodeSpanning"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 1
	  param inout name "b" type class_ref 139778 // TreeMultiItemBase
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Calculate the spanning of the individual nodes "
      end

      operation 174978 "SetRecursiveCheckState"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 2
	  param inout name "n" type class_ref 139906 // TreeMultiItemNode
	  param in name "check" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Recurse to all the children and set the checkbox state (even when there is no checkbox) "
      end

      operation 175106 "ScanTristateCheckstates"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 1
	  param inout name "b" type class_ref 139778 // TreeMultiItemBase
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* From current checked node, all children will be scanned and the parent node of this node
        will get tristate if the checked items are scattered (some are some aren't). If all nodes in this
        node are checked, the parent node gets checked all the way up to the last one that matches
        criteria. If all are cleared, parent node gets cleared "
      end

      operation 175234 "InsertNode"
	preserve_cpp_body_indent private return_type class_ref 140418 // wxTreeMultiItem
	nparams 4
	  param inout name "ParentPtr" type class_ref 139906 // TreeMultiItemNode
	  param in name "Position" explicit_type "size_t"
	  param in name "Caption" explicit_type "wxString"
	  param in name "Name" explicit_type "wxString"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}, const ${t2} & ${p2}${v2}, const ${t3} & ${p3}${v3}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}, const ${t2} & ${p2}, const ${t3} & ${p3}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* \\name Private add and delete methods

       @{

   
* Inserts a node into the parent's node at the specified position.

       As this is a private method error checking is limited. Therefore, it has to be guaranteed that this method

       is only called with a valid parent node pointer.

       The position is zero based. In case the position is equal or larger than the current number of

       parent's elements the new node is appended.

       The newly inserted node is being returned.

   "
      end

      operation 175362 "InsertWindow"
	preserve_cpp_body_indent private return_type class_ref 140418 // wxTreeMultiItem
	nparams 6
	  param inout name "ParentPtr" type class_ref 139906 // TreeMultiItemNode
	  param in name "Position" explicit_type "size_t"
	  param inout name "WindowPtr" type class_ref 136322 // wxWindow
	  param in name "Name" explicit_type "wxString"
	  param in name "Info" type class_ref 140546 // wxTreeMultiWindowInfo
	  param in name "Flags" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} * ${p2}${v2}, const ${t3} & ${p3}${v3}, const ${t4} & ${p4}${v4}, ${t5} ${p5}${v5}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// wxTreeMultiCtrl::InsertNode(TreeMultiItemNode*, size_t, wxString const&, wxString const&) 

${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}, ${t2} * ${p2}, const ${t3} & ${p3}, const ${t4} & ${p4}, ${t5} ${p5}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Inserts a window into the parent's node at the specified position.

       As this is a private method error checking is limited. Therefore, it has to be guaranteed that this method

       is only called with a valid parent node and window pointer.

       The position is zero based. In case the position is equal or larger than the current number of

       parent's elements the new node is appended.

       The newly inserted window is being returned.

   "
      end

      operation 175490 "Init"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* @}

   "
      end

      operation 175618 "OnPaint"
	private explicit_return_type "void"
	nparams 1
	  param inout name "event" explicit_type "wxPaintEvent"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment " handlers
---------
virtual void OnDraw(wxDC& dc);
"
      end

      operation 175746 "OnMouseClick"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 1
	  param inout name "event" explicit_type "wxMouseEvent"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 175874 "OnRightMouseClick"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 1
	  param inout name "Event" explicit_type "wxMouseEvent"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 176002 "OnKey"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 1
	  param inout name "event" explicit_type "wxKeyEvent"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 176130 "OnSize"
	private explicit_return_type "void"
	nparams 1
	  param inout name "event" explicit_type "wxSizeEvent"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 176258 "RecalculateSpanSizes"
	preserve_cpp_body_indent private explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Recalculates the spanning controls "
      end

      operation 176386 "wxTreeMultiCtrl"
	cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw} : _create_called(false)
    {

        Init();
    };
"
	
	
	
	
	comment "* Two step constructor. Call Create when this constructor is called to build up the
        wxTreeMultiCtrl
    "
      end

      operation 176514 "wxTreeMultiCtrl"
	cpp_inline public explicit_return_type ""
	nparams 7
	  param inout name "parent" type class_ref 136322 // wxWindow
	  param in name "id" explicit_type "wxWindowID"
	    defaultvalue "-1"
	  param in name "pos" explicit_type "wxPoint"
	    defaultvalue "wxDefaultPosition"
	  param in name "size" explicit_type "wxSize"
	    defaultvalue "wxDefaultSize"
	  param in name "style" explicit_type "long"
	    defaultvalue "wxTMC_DEFAULT_STYLE"
	  param in name "validator" explicit_type "wxValidator"
	    defaultvalue "wxDefaultValidator"
	  param in name "name" explicit_type "wxString"
	    defaultvalue "wxTreeMultiCtrlNameStr"
	cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}, const ${t2} & ${p2}${v2}, const ${t3} & ${p3}${v3}, ${t4} ${p4}${v4}, const ${t5} & ${p5}${v5}, const ${t6} & ${p6}${v6}${)}${volatile}${throw} : _style(style | wxTAB_TRAVERSAL)
        , _create_called(false)
    {
        Create(parent, id, pos, size, style, validator, name);
    };
"
	
	
	
	
	comment "* The default constructor. The style wxTAB_TRAVERSAL is enforced to make sure that the
        focus handling is being done correctly. The styles to be used are styles valid for
        the wxWindow and wxScrolledWindow
    "
      end

      operation 176642 "~wxTreeMultiCtrl"
	preserve_cpp_body_indent cpp_virtual public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw};
"
	cpp_def "${comment}${inline}${class}::${name}${(}${)}${throw}{
${body}}
"
	
	
	
	
	comment "* Destructor "
      end

      operation 176770 "Create"
	public explicit_return_type "bool"
	nparams 7
	  param inout name "parent" type class_ref 136322 // wxWindow
	  param in name "id" explicit_type "wxWindowID"
	    defaultvalue "-1"
	  param in name "pos" explicit_type "wxPoint"
	    defaultvalue "wxDefaultPosition"
	  param in name "size" explicit_type "wxSize"
	    defaultvalue "wxDefaultSize"
	  param in name "style" explicit_type "long"
	    defaultvalue "wxTMC_DEFAULT_STYLE"
	  param in name "validator" explicit_type "wxValidator"
	    defaultvalue "wxDefaultValidator"
	  param in name "name" explicit_type "wxString"
	    defaultvalue "wxTreeMultiCtrlNameStr"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}, const ${t2} & ${p2}${v2}, const ${t3} & ${p3}${v3}, ${t4} ${p4}${v4}, const ${t5} & ${p5}${v5}, const ${t6} & ${p6}${v6}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} ${p1}, const ${t2} & ${p2}, const ${t3} & ${p3}, ${t4} ${p4}, const ${t5} & ${p5}, const ${t6} & ${p6}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Two step creation. Whenever the control is created without any parameters, use Create to actually
        create it. Don't access the control's public methods before this is called

        \\sa wxTreeMultiCtrl()
    "
      end

      operation 176898 "AddRoot"
	preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
	nparams 2
	  param in name "caption" explicit_type "wxString"
	  param in name "name" explicit_type "wxString"
	    defaultvalue "wxEmptyString"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, const ${t1} & ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment " accessors
----------
* @name Add and delete methods
        To add and delete node items like a Root item, Window item or Node item. This allows the user to
        manipulate the tree, and build it up.
        @{
    
* Adds a root node to the wxTreeMultiItem. There can be many root nodes. Use this wxTreeMultiNode pointer to add
        more subnodes to it. "
      end

      operation 177026 "AppendWindow"
	preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
	nparams 5
	  param in name "ParentItem" type class_ref 140418 // wxTreeMultiItem
	  param inout name "window" type class_ref 136322 // wxWindow
	    defaultvalue "NULL"
	  param in name "name" explicit_type "wxString"
	    defaultvalue "wxEmptyString"
	  param in name "info" type class_ref 140546 // wxTreeMultiWindowInfo
	    defaultvalue "wxTreeMultiWindowInfoDefault"
	  param in name "flags" explicit_type "int"
	    defaultvalue "0"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} * ${p1}${v1}, const ${t2} & ${p2}${v2}, const ${t3} & ${p3}${v3}, ${t4} ${p4}${v4}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, ${t1} * ${p1}, const ${t2} & ${p2}, const ${t3} & ${p3}, ${t4} ${p4}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Adds a window to the tree control. Use this wxTreeMultiItem method to add a window class to the

        current wxTreeMultiItem. The wxTreeMultiItem must point to a Node class. If this is not the case

        an empty wxTreeMultiItem is returned. The mask is used to override the mask settings of the

        wxTreeMultiWindowInfo class. This can be handy to set or clear extra flags only needed for certain

        situations "
      end

      operation 177154 "InsertWindow"
	preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
	nparams 6
	  param in name "ParentItem" type class_ref 140418 // wxTreeMultiItem
	  param in name "Position" explicit_type "size_t"
	  param inout name "window" type class_ref 136322 // wxWindow
	    defaultvalue "NULL"
	  param in name "name" explicit_type "wxString"
	    defaultvalue "wxEmptyString"
	  param in name "info" type class_ref 140546 // wxTreeMultiWindowInfo
	    defaultvalue "wxTreeMultiWindowInfoDefault"
	  param in name "flags" explicit_type "int"
	    defaultvalue "0"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} * ${p2}${v2}, const ${t3} & ${p3}${v3}, const ${t4} & ${p4}${v4}, ${t5} ${p5}${v5}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, ${t1} ${p1}, ${t2} * ${p2}, const ${t3} & ${p3}, const ${t4} & ${p4}, ${t5} ${p5}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Adds a window to the tree control. Use this method to add a window class at the specified position

       of the parent's wxTreeMultiItem. In case the position is smaller than the current number of children all elements

       are shifted upwards, otherwise the new window is appended to the parent's wxTreeMultiItem.

       The parent wxTreeMultiItem must point to a Node class. If this is not the case an

       empty wxTreeMultiItem is returned.

   "
      end

      operation 177282 "PrependWindow"
	preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
	nparams 5
	  param in name "ParentItem" type class_ref 140418 // wxTreeMultiItem
	  param inout name "window" type class_ref 136322 // wxWindow
	    defaultvalue "NULL"
	  param in name "name" explicit_type "wxString"
	    defaultvalue "wxEmptyString"
	  param in name "info" type class_ref 140546 // wxTreeMultiWindowInfo
	    defaultvalue "wxTreeMultiWindowInfoDefault"
	  param in name "flags" explicit_type "int"
	    defaultvalue "0"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} * ${p1}${v1}, const ${t2} & ${p2}${v2}, const ${t3} & ${p3}${v3}, ${t4} ${p4}${v4}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// wxTreeMultiCtrl::InsertWindow(wxTreeMultiItem const&, size_t, wxWindow*, wxString const&, wxTreeMultiWindowInfo const&, int) 

${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, ${t1} * ${p1}, const ${t2} & ${p2}, const ${t3} & ${p3}, ${t4} ${p4}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Adds a window to the tree control. Use this method to add a window class as the first element

       of the parent's wxTreeMultiItem. The parent wxTreeMultiItem must point to a Node class. If this is not the case an

       empty wxTreeMultiItem is returned.

   "
      end

      operation 177410 "AppendNode"
	preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
	nparams 3
	  param in name "ParentItem" type class_ref 140418 // wxTreeMultiItem
	  param in name "caption" explicit_type "wxString"
	    defaultvalue "wxEmptyString"
	  param in name "name" explicit_type "wxString"
	    defaultvalue "wxEmptyString"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, const ${t1} & ${p1}${v1}, const ${t2} & ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// wxTreeMultiCtrl::PrependWindow(wxTreeMultiItem const&, wxWindow*, const wxString &, wxTreeMultiWindowInfo const&, int) 

${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, const ${t1} & ${p1}, const ${t2} & ${p2}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Adds a node to the tree control. Use this wxTreeMultiItem method to add a recursive subnode class as the last element

        of the parent's wxTreeMultiItem. The parent wxTreeMultiItem must point to a Node class. If this is not the case

        an empty wxTreeMultiItem is returned. A node can contain multiple nodes or window classes "
      end

      operation 177538 "InsertNode"
	preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
	nparams 4
	  param in name "ParentItem" type class_ref 140418 // wxTreeMultiItem
	  param in name "Position" explicit_type "size_t"
	  param in name "caption" explicit_type "wxString"
	  param in name "name" explicit_type "wxString"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}, const ${t2} & ${p2}${v2}, const ${t3} & ${p3}${v3}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// wxTreeMultiCtrl::AppendNode(wxTreeMultiItem const&, const wxString &, const wxString&) 

${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, ${t1} ${p1}, const ${t2} & ${p2}, const ${t3} & ${p3}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Adds a node to the tree control. Use this method to add a recursive subnode class at the specified position

       of the parent's wxTreeMultiItem. In case the position is smaller than the current number of nodes all elements

       are shifted upwards, otherwise the new node is appended to the parent's wxTreeMultiItem.

       The parent wxTreeMultiItem must point to a Node class. If this is not the case an

       empty wxTreeMultiItem is returned. A node can contain multiple nodes or window classes.

   "
      end

      operation 177666 "PrependNode"
	preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
	nparams 3
	  param in name "ParentItem" type class_ref 140418 // wxTreeMultiItem
	  param in name "caption" explicit_type "wxString"
	    defaultvalue "wxEmptyString"
	  param in name "name" explicit_type "wxString"
	    defaultvalue "wxEmptyString"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, const ${t1} & ${p1}${v1}, const ${t2} & ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// wxTreeMultiCtrl::InsertNode(wxTreeMultiItem const&, size_t, wxString const&, wxString const&) 

${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, const ${t1} & ${p1}, const ${t2} & ${p2}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Adds a node to the tree control. Use this method to add a recursive subnode class as the first element

       of the parent's wxTreeMultiItem. The parent wxTreeMultiItem must point to a Node class. If this is not the case an

       empty wxTreeMultiItem is returned. A node can contain multiple nodes or window classes.

   "
      end

      operation 177794 "Delete"
	preserve_cpp_body_indent public explicit_return_type "bool"
	nparams 1
	  param inout name "item" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// wxTreeMultiCtrl::PrependNode(wxTreeMultiItem const&, wxString const&, wxString const&) 

${comment}${inline}${type} ${class}::${name}${(}${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Delete item from the tree control. Whenever it is present, delete it. If not, return false. After

        deletion the wxTreeMultiItem is 0, thus IsOk will return false "
      end

      operation 177922 "DeleteAllItems"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "" explicit_type "void"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {

      this->_root.Clear();

      this->m_SelectedItems.Clear();

      Refresh();

    };
"
	
	
	
	
	comment "* Deletes all the items from the wxTreeMultiCtrl. "
      end

      operation 178050 "DeleteChildren"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 1
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Deletes all children of the current node. The wxTreeMultiItem needs to be of type Node to
        do this. Call GetParentNode to get the parent wxTreeMultiItem which is always a node. "
      end

      operation 178178 "ExpandNodes"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 1
	  param in name "recursive" explicit_type "bool"
	    defaultvalue "false"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* @}
    
* @name Expand and collapse methods
         These methods are all for items of type Node.
        @{
    
* Expand all nodes and subnodes. Recursive = true means all subnodes are also expanded. "
      end

      operation 178306 "CollapseNodes"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 1
	  param in name "recursive" explicit_type "bool"
	    defaultvalue "false"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Collapses all nodes and subnodes. Recursive = true means all subnodes are also expanded. "
      end

      operation 178434 "Expand"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 2
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	  param in name "recursive" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Expands given node, and with recursive, also the subnodes "
      end

      operation 178562 "Collapse"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 2
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	  param in name "recursive" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Collapses given node, and with recursive, also the subnodes. If this item is not a node, but a window.
        the parent is resolved and that node is collapsed "
      end

      operation 178690 "CollapseAndReset"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 1
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Collapses this node and removes all children from it. This is only applicable on
        wxTreeMultiItems which are of type Node / Root. "
      end

      operation 178818 "Fold"
	cpp_inline public explicit_return_type "void"
	nparams 2
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	  param in name "expand" explicit_type "bool"
	    defaultvalue "true"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
        if(expand)
            Expand(item, false);
        else
            Collapse(item, false);
    };
"
	
	
	
	
	comment "* Folds the given node. The same as Expand and Collapse, but the state can be
        given through a parameter "
      end

      operation 178946 "GetSelectedItemCount"
	const cpp_inline public explicit_return_type "size_t"
	nparams 1
	  param in name "" explicit_type "void"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {return this->m_SelectedItems.GetCount();};
"
	
	
	
	
	comment "* @}

    
* @name Selection manipulation

         These methods allow you to select, unselect or test wxTreeMultiItems on selection.

         Currently only items of type Node can be manipulated.

        @{

    
* Returns the number of selected items. "
      end

      operation 179074 "GetFirstSelectedItem"
	preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
	nparams 1
	  param in name "" explicit_type "void"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// Selection manipulation


${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Returns the first selected item.

       If there is no selected item an invalid tree multi item is returned.

   "
      end

      operation 179202 "GetLastSelectedItem"
	preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
	nparams 1
	  param in name "" explicit_type "void"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// wxTreeMultiCtrl::GetFirstSelectedItem(void) const 

${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Returns the last selected item.

       If there is no selected item an invalid tree multi item is returned.

   "
      end

      operation 179330 "GetSelectedItem"
	preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
	nparams 1
	  param in name "Index" explicit_type "size_t"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// wxTreeMultiCtrl::GetLastSelectedItem(void) const 

${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Returns a selected item with the specified index.

       If there is no selected item with the passed index an invalide tree multi item is returned.

   "
      end

      operation 179458 "GetSelectedItemIndex"
	preserve_cpp_body_indent const public explicit_return_type "size_t"
	nparams 1
	  param in name "Item" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// wxTreeMultiCtrl::GetSelectedItem(size_t Index) const 

${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Returns the index of the selected item.

       In case the item is not selected \"GetSelectedItemCount()\" - which is an invalid index - is returned.

   "
      end

      operation 179586 "SelectItem"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 3
	  param in name "Item" type class_ref 140418 // wxTreeMultiItem
	  param in name "UnselectOthers" explicit_type "bool"
	    defaultvalue "true"
	  param in name "ExpandSelection" explicit_type "bool"
	    defaultvalue "false"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// wxTreeMultiCtrl::GetSelectedItemIndex(wxTreeMultiItem const&) const 

${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, ${t1} ${p1}, ${t2} ${p2}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Selects the specified item AND in case

        - UnselectOthers is set all other selected items are going to be unselected;

        - ExpandSelection is set all items between the last selected item and the passed item

          are selected, too (in case there this is the first selection all items between the first root

          and the passed item are selected).

       If the passed item is already selected the other parameters are ignored.

       Please not that currently only nodes can be selected, therefore, if any other item is passed nothing will happen.

   "
      end

      operation 179714 "UnselectAll"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 1
	  param in name "" explicit_type "void"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// wxTreeMultiCtrl::SelectItem(wxTreeMultiItem const&, bool, bool) 

${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Unselect all selected items. "
      end

      operation 179842 "Unselect"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 1
	  param in name "Item" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// wxTreeMultiCtrl::UnselectAll(void) 

${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Unselect specified item "
      end

      operation 179970 "Exclude"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 1
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* @}

    
* \\name Visibility manipulation

        These methods allow you to manipulate a certain wxTreeMultiItem to temporarily exclude or to include

        the node from drawing. Whenever it is excluded, all operations can still be performed, however

        the node may not be visible.
        @{
    
* Excludes this node from drawing. When excluded, the node will dissapear from the control but is still
        physically present in the tree itself. If this node is a composite node with children, they will all be
        hidden from the control. "
      end

      operation 180098 "Include"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 1
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Includes an excluded node. If the node was already present on the drawing, nothing happens. If the
        node is included after exclusion it will become visible. If the parent node is still excluded or
        collapsed (not visible) this will not show, until the parent node shows "
      end

      operation 180226 "GetExcludedParent"
	preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
	nparams 1
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Returns the parent that is responsible for excluding this node. If there is no excluded node as parent,
        the wxTreeMultiItem is zero. "
      end

      operation 180354 "HitTest"
	preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
	nparams 2
	  param in name "pt" explicit_type "wxPoint"
	  param inout name "flags" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// wxTreeMultiCtrl::OnRightMouseClick(wxMouseEvent&) 

${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, ${t1} & ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* @}
    
* Checks if the point is under one of the given areas. The returned areas can be
        \\li wxTMC_HITTEST_GUTTER If the front part of the item is clicked (where the node is)
        \\li wxTMC_HITTEST_WINDOW If located in the window area
        \\li wxTMC_HITTEST_CAPTION If located on the caption of the MultiTreeItemNode


        Returned is the item which is located under the mouse, or none (IsOk = false) if

        no item under the mouse "
      end

      operation 180482 "FindItem"
	preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
	nparams 4
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	  param in name "name" explicit_type "wxString"
	  param in name "ignoreCase" explicit_type "bool"
	    defaultvalue "false"
	  param in name "skipFirst" explicit_type "bool"
	    defaultvalue "false"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, const ${t1} & ${p1}${v1}, ${t2} ${p2}${v2}, ${t3} ${p3}${v3}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, const ${t1} & ${p1}, ${t2} ${p2}, ${t3} ${p3}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* @name Find methods

         These methods are used for finding a node in the wxTreeMultiCtrl.

        @{
    
* Searches for the given name from the given level and lower. It will return a wxTreeMultiItem which needs
        to be checked with IsOk() to see if it is a correct item. IsRootItem, IsNodeItem and IsWindowItem can be
        used to determine the type of item. If the search returned an item which doesn't satisfy the query, you can
        restart the search from here, with skip = true to skip the passed item. "
      end

      operation 180610 "FindItem"
	cpp_inline public return_type class_ref 140418 // wxTreeMultiItem
	nparams 2
	  param in name "name" explicit_type "wxString"
	  param in name "ignoreCase" explicit_type "bool"
	    defaultvalue "false"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
        return FindItem(wxTreeMultiItem(&_root), name, ignoreCase, false);
    };
"
	
	
	
	
	comment "* Searches all nodes for the given name and returns the one found. This is a specialised method for FindItem "
      end

      operation 180738 "GetChildrenCount"
	cpp_inline public explicit_return_type "int"
	nparams 1
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        if(item.IsNodeItem())
        {
            TreeMultiItemNode *n = (TreeMultiItemNode *)item.GetItem();
            return n->GetNodeCount();
        }

        return -1;
    };
"
	
	
	
	
	comment "* @}
    
* Returns the number of children in this node. If this node is not of type Node, count returns -1. "
      end

      operation 180866 "GetFocus"
	preserve_cpp_body_indent public return_type class_ref 140418 // wxTreeMultiItem
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* This method finds the current focused window, and returns the wxTreeMultiItem that has this window as pointer.
        If the wxTreeMultiItem is not ok, the focused window is on a sub-panel, or not on this control. If the focus is
        on a sub-panel, this panel will handle the focusing. If you are still interested in this window, try
        wxWindow::FindFocus which will always return with a pointer if a wxWindow has focus "
      end

      operation 180994 "GetBooleanValue"
	preserve_cpp_body_indent public explicit_return_type "bool"
	nparams 1
	  param in name "wndId" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* @name Smart window Get/Set methods
         These methods are used for quickly getting or setting primitive values, like boolean, string, or selections into
         primitive wxWindow controls like a wxRadioButton, wxCheckBox, wxTextCtrl, etc.
         The methods allow you to quickly set e.g. a boolean value by using the wxWindow ID of the control. A type
         check is performed before the value is actually set with the appropiate method for it. If it fails, an assertion
         will follow in debug mode. If you want to get values back similar get methods are present to return values.
         This allows the user to quickly retrieve or set values by ID, without the fuss of remembering the pointer or
         node ID of the wxTreeMultiCtrl.
        @{
    
* This function calls FindWindow on the wxTreeMultiCtrl to find the window with the given ID (which is added with
        AppendWindow). When it is found, it is type casted towards a <b>wxCheckBox</b> and <b>wxRadioButton</b>. Whenever
        it finds a proper type it will return true or false. Whenever no proper type is found, it will return with false.
        In debug mode it will cause an assertion failure as well, to notify the developer something is wrong.

        \\sa SetBooleanValue
    "
      end

      operation 181122 "GetTextValue"
	preserve_cpp_body_indent public explicit_return_type "wxString"
	nparams 1
	  param in name "wndId" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* This function calls FindWindow on the wxTreeMultiCtrl to find the window with the given ID (which is added with
        AppendWindow). When it is found, it is type casted towards a <b>wxTextCtrl</b>, <b>wxChoice</b> and <b>wxComboBox</b>.
        Whenever it finds a proper type it will return the (selected) text in the control. Whenever no proper type is found,
        it will return with an empty string. In debug mode it will cause an exception error as well if the cast fails, to notify
        the developer something is wrong.

        \\sa SetTextValue
    "
      end

      operation 181250 "SetBooleanValue"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 2
	  param in name "wndId" explicit_type "int"
	  param in name "value" explicit_type "bool"
	    defaultvalue "true"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* This function calls FindWindow on the wxTreeMultiCtrl to find the window with the given ID (which is added with
        AppendWindow). When it is found, it is type casted towards a <b>wxCheckBox</b> and <b>wxRadioButton</b>. Whenever
        it finds a proper type it set the control's value to the given boolean parameter. Nothing happens when no proper type
        is found, however debug mode it will cause an assertion failure.

        \\sa GetBooleanValue
    "
      end

      operation 181378 "SetTextValue"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 2
	  param in name "wndId" explicit_type "int"
	  param in name "value" explicit_type "wxString"
	    defaultvalue "wxEmptyString"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}, const ${t1} & ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* This function calls FindWindow on the wxTreeMultiCtrl to find the window with the given ID (which is added with
        AppendWindow). When it is found, it is type casted towards a <b>wxTextCtrl</b>. If the control is not found or
        of the wrong type, an asserion failure (in debug mode) follows. <br><i><b>NOTE: </b></i> this method
        does not typecast to wxChoice or wxComboBox and the likes. If a selection in one of those needs to be set, use the
        SetSelectionValue / GetSelectionValue combination.
        \\sa GetTextValue, GetSelectionValue, SetSelectionValue
    "
      end

      operation 181506 "GetWindow"
	cpp_inline public return_type class_ref 136322 // wxWindow
	nparams 1
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        if(item.IsWindowItem())
            return ((TreeMultiItemWindow *)item.GetItem())->GetWindow();
        return 0;
    };
"
	
	
	
	
	comment "* Retrieves the wxWindow * associated with the wxTreeMultiItem. This only works for Window typed wxTreeMultiItem
        classes. If this type does not match or no window is associated, 0 is returned. "
      end

      operation 181634 "SetSelectionValue"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 2
	  param in name "wndId" explicit_type "int"
	  param in name "sel" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* This function calls FindWindow on the wxTreeMultiCtrl to find the window with the given ID (which is added with
        AppendWindow). When it is found, it is type casted towards a <b>wxListBox, wxChoice, wxComboBox</b>.
        If the control is not found or of the wrong type, an asserion failure (in debug mode) follows. If it is found
        the selection is set in the control.
    "
      end

      operation 181762 "GetSelectionValue"
	preserve_cpp_body_indent public explicit_return_type "int"
	nparams 1
	  param in name "wndId" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* This function calls FindWindow on the wxTreeMultiCtrl to find the window with the given ID (which is added with
        AppendWindow). When it is found, it is type casted towards a <b>wxListBox, wxChoice, wxComboBox</b>.
        If the control is not found or of the wrong type, an asserion failure (in debug mode) follows. In release mode -1 is
        returned. If it is found the selection index is returned.
    "
      end

      operation 181890 "GetSelectionValues"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 2
	  param in name "wndId" explicit_type "int"
	  param inout name "sels" explicit_type "wxArrayInt"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}, ${t1} & ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* This function calls FindWindow on the wxTreeMultiCtrl to find the window with the given ID (which is added with
        AppendWindow). When it is found, it is type casted towards a <b>wxListBox</b>. If the control is not found or
        of the wrong type, an asserion failure (in debug mode) follows. In release mode an empty wxArrayInt is returned.
        If it is found the selections are stored in the wxArrayInt. This is only valid for wxListBox classes with multiple
        selection flag set.
    "
      end

      operation 182018 "GetCheckboxState"
	public explicit_return_type "int"
	nparams 1
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Gets the checkbox state of the wxTreeMultiItem pointed out by \"item\". If the item does not have a checkbox
        associated (or the item is not ok), it will return -1. If the checkbox is checked it will return 1,

        unchecked is 0, and tri-state (usually only for caption nodes) it will return 2. <b>This needs USE_CHECKBOXVIEW

        set to YES, or CHECKBOXVIEW=1 during compile</b>"
      end

      operation 182146 "SetCheckboxState"
	cpp_inline public explicit_return_type "void"
	nparams 2
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	  param in name "state" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
		wxCHECK2( item.IsOk(), return );
		TreeMultiItemBase *b = item.GetItem();
		if( b->GetCheckbox() )
			b->SetCheckboxState( state );
		RedrawFromNode( item.GetItem()->GetParent() );
	};
"
	
	
	
	
	comment "* Sets the checkbox state of the wxTreeMultiItem pointed out by \"item\". If the item does not have a checkbox
        associated (or the item is not ok), it will simply ignore this. <b>This needs USE_CHECKBOXVIEW
        set to YES, or CHECKBOXVIEW=1 during compile</b>. Contributed by Thomas Enickl."
      end

      operation 182274 "SetSpacingY"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "spacingY" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        if(spacingY >= 0)
        {
            _spacingY = spacingY;
            RedrawFromNode(0);
        }
    };
"
	
	
	
	
	comment "* @}
    
* @name Extended visibility and manipulation methods
        These methods alter the wxTreeMultiCtrl appearance, or add more functionality like checkboxes before each node.
        @{
    
* Sets the Y spacing of the wxTreeMultiCtrl to a new size. This can be used to give the controls some more
        spacing in between "
      end

      operation 182402 "GetSpacingY"
	const cpp_inline public explicit_return_type "int"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return _spacingY;
    };
"
	
	
	
	
	comment "* Gets the Y spacing of the wxTreeMultiCtrl. "
      end

      operation 182530 "SetCheckboxView"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "value" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        _checkboxView = value;
    };
"
	
	
	
	
	comment "* This method toggles the checkbox view mode. Whenever set to true, the next window item, or caption node item
        will get a checkbox. <b>This needs USE_CHECKBOXVIEW set to YES, or CHECKBOXVIEW=1 during compile</b>
        \\sa GetCheckboxView, wxTreeMultiWindowInfo::SetDefaultCheckState
    "
      end

      operation 182658 "GetCheckboxView"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return _checkboxView;
    };
"
	
	
	
	
	comment "* This method returns the checkbox state currently used. <b>This needs USE_CHECKBOXVIEW set to YES, or
        CHECKBOXVIEW=1 during compile</b>
        \\sa SetCheckboxView, wxTreeMultiWindowInfo::SetDefaultCheckState, wxTreeMultiWindowInfo::GetDefaultCheckState
    "
      end

      operation 182786 "GetFirstRoot"
	const cpp_inline public return_type class_ref 140418 // wxTreeMultiItem
	nparams 1
	  param in name "" explicit_type "void"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {return wxTreeMultiItem(this->_root.First());};
"
	
	
	
	
	comment "* @}
    
* @name Iteration methods

        Allows the user to iterate through a wxTreeMultiCtrl node, and get all the children or siblings.

        To start an iteration from the lowest level the functions GetFirstRoot and GetLastRoot are provided.

        @{

    
* Returns the first root. "
      end

      operation 182914 "GetLastRoot"
	const cpp_inline public return_type class_ref 140418 // wxTreeMultiItem
	nparams 1
	  param in name "" explicit_type "void"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {return wxTreeMultiItem(this->_root.Last());};
"
	
	
	
	
	comment "* Returns the last root. "
      end

      operation 183042 "GetParent"
	preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
	nparams 1
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Returns the items parent. "
      end

      operation 183170 "GetFirstChild"
	preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
	nparams 2
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	  param inout name "cookie" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// wxTreeMultiCtrl::GetParent(wxTreeMultiItem const& item) const 

${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, ${t1} & ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Returns the first child of this node. The type of wxTreeMultiItem needs to be of Node. Whenever not succesful,

        the item returned is not ok (IsOk = false). Upon success, a valid child is returned. The cookie variable doesn't

        need to be initialized "
      end

      operation 183298 "GetNextChild"
	preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
	nparams 2
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	  param inout name "cookie" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, ${t1} & ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Returns the next child in the iteration on the level of 'item'. Make sure you called GetFirstChild first
        before calling this one "
      end

      operation 183426 "GetLastChild"
	preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
	nparams 1
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Returns the last child of this node. The type of 'item' needs to be of Node. Whenever not succesful,
        the item returned is not ok (IsOk = false). Upon success, a valid last child is returned. "
      end

      operation 183554 "GetNextSibling"
	preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
	nparams 1
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Returns the next sibling of the passed item. "
      end

      operation 183682 "GetPrevSibling"
	preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
	nparams 1
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// wxTreeMultiCtrl::GetNextSibling(wxTreeMultiItem const&) const 

${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Returns the previous sibling of the passed item. "
      end

      operation 183810 "GetNext"
	preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
	nparams 1
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// wxTreeMultiCtrl::GetPrevSibling(wxTreeMultiItem const&) const 

${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Returns the next item. \"Next\" is defined by the following order:

        - in case the current item has a child it is the first child of the current item;

        - in case the current item has a next sibling as the next sibling;

        - as the parent's (or one of its ancestor's) next sibling.

   "
      end

      operation 183938 "GetPrevious"
	preserve_cpp_body_indent const public return_type class_ref 140418 // wxTreeMultiItem
	nparams 1
	  param in name "item" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// wxTreeMultiCtrl::GetNextSibling(wxTreeMultiItem const&) const 

${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Returns the previous item. \"Previous\" is defined by the following order:

        - in case the current item has a child it is the last child of the current item;

        - in case the current item has a previous sibling it is the previous sibling;

        - as the parent's (or one of its ancestor's) previous sibling.

   "
      end

      operation 184066 "GetCaptionFont"
	const cpp_inline public explicit_return_type "wxFont"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return _captionFont;
    };
"
	
	
	
	
	comment "* @}

    
* @name Get and set methods
        These methods allow you to set or get certain properties of the wxTreeMultiCtrl.
        @{
    
* Get the currently used font for the caption headers in the wxTreeMultiCtrl. If you want to alter this
        font, simply obtain it and copy it to a local font. After that, set this font back using SetCaptionFont()
    "
      end

      operation 184194 "SetCaptionFont"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 1
	  param in name "font" explicit_type "wxFont"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* Sets the font to be used for the text caption headers. This triggers a complete redraw because x,y sizes can
        differ, and ofcourse all nodes need to be updated. You can call this method at any time not only at the
        beginning. "
      end

      operation 184322 "OnDraw"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 1
	  param inout name "dc" explicit_type "wxDC"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "// wxTreeMultiCtrl::GetPrevious(wxTreeMultiItem const&) const 
// WDR: handler implementations for wxTreeMultiCtrl


${comment}${inline}${type} ${class}::${name}${(}${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "* @}

    "
      end
    end

    class 140802 "typedef23"
      visibility package stereotype "typedef" explicit_base_type "wxScrolledWindow"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 140930 "wxTreeMultiEvent"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
   \\section treemultievent Event handlers for wxTreeMultiCtrl
   
   Event handlers for wxTreeMultiCtrl are similar to wxTreeEvents. But they are
   optimized for the wxTreeMultiCtrl class.
"
      classrelation 136066 // <generalisation>
	relation 136066 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 136066 // <generalisation>
	  b parent class_ref 141058 // typedef24
      end

      operation 184450 "wxTreeMultiEvent"
	preserve_cpp_body_indent public explicit_return_type ""
	nparams 2
	  param in name "InitEventType" explicit_type "wxEventType"
	    defaultvalue "wxEVT_NULL"
	  param in name "InitItem" type class_ref 140418 // wxTreeMultiItem
	    defaultvalue "wxTreeMultiItem()"
	cpp_decl "    ${comment}${inline}${name}${(}${t0} ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${volatile}${throw};
"
	cpp_def "// constructors / destructor:

${comment}${inline}${class}::${name}${(}${t0} ${p0}, const ${t1} & ${p1}${)}
                 :wxNotifyEvent(InitEventType), m_Item(InitItem)
${throw}{
${body}}
"
	
	
	
	
	comment "WXDLLEXPORT
/
/ The default constructor
/"
      end

      operation 184578 "Clone"
	const cpp_virtual cpp_inline public explicit_return_type "wxEvent"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {return new wxTreeMultiEvent(*this);};
"
	
	
	
	
	comment " inherited functions:
 wxEvent:
 cloning:"
      end

      operation 184706 "GetItem"
	const cpp_inline public return_type class_ref 140418 // wxTreeMultiItem
	nparams 1
	  param in name "" explicit_type "void"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
    return this->m_Item;
  };
"
	
	
	
	
	comment " item handling:"
      end

      operation 184834 "SetItem"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "NewItem" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
    this->m_Item = NewItem;
  };
"
	
	
	
	
      end

      operation 184962 "GetOldItem"
	const cpp_inline public return_type class_ref 140418 // wxTreeMultiItem
	nparams 1
	  param in name "" explicit_type "void"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
    return this->m_OldItem;
  };
"
	
	
	
	
	comment " old item handling:"
      end

      operation 185090 "SetOldItem"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "NewItem" type class_ref 140418 // wxTreeMultiItem
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
    this->m_OldItem = NewItem;
  };
"
	
	
	
	
      end
    end

    class 141058 "typedef24"
      visibility package stereotype "typedef" explicit_base_type "wxNotifyEvent"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end
  end

  deploymentview 128258 "treemultictrl"
    //deployment diagram settings
    package_name_in_tab default show_context default write_horizontally default auto_label_position default draw_all_relations default shadow default
    draw_component_as_icon default show_component_req_prov default show_component_rea default show_stereotype_properties default
    artifact 131458 "TreeMultiItemBase"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 139778 // TreeMultiItemBase
      end
    end

    artifact 131586 "TreeMultiItemNode"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 139906 // TreeMultiItemNode
      end
    end

    artifact 131714 "TreeMultiItemRoot"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 140034 // TreeMultiItemRoot
      end
    end

    artifact 131842 "TreeMultiItemWindow"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 140162 // TreeMultiItemWindow
      end
    end

    artifact 131970 "wxTreeMultiCtrl"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 140290 // anonymous1
	class_ref 140418 // wxTreeMultiItem
	class_ref 140546 // wxTreeMultiWindowInfo
	class_ref 140802 // typedef23
	class_ref 140674 // wxTreeMultiCtrl
      end
    end

    artifact 132098 "wxTreeMultiEvent"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 141058 // typedef24
	class_ref 140930 // wxTreeMultiEvent
      end
    end
  end
end