// This file has been generated by Py++.

#include "boost/python.hpp"
#include "python_CEGUI.h"
#include "Tree.pypp.hpp"

namespace bp = boost::python;

struct Tree_wrapper : CEGUI::Tree, bp::wrapper< CEGUI::Tree > {

    Tree_wrapper(::CEGUI::String const & type, ::CEGUI::String const & name )
    : CEGUI::Tree( boost::ref(type), boost::ref(name) )
      , bp::wrapper< CEGUI::Tree >(){
        // constructor
    
    }

    virtual void initialise(  ) {
        if( bp::override func_initialise = this->get_override( "initialise" ) )
            func_initialise(  );
        else{
            this->CEGUI::Tree::initialise(  );
        }
    }
    
    void default_initialise(  ) {
        CEGUI::Tree::initialise( );
    }

    virtual void setLookNFeel( ::CEGUI::String const & look ) {
        if( bp::override func_setLookNFeel = this->get_override( "setLookNFeel" ) )
            func_setLookNFeel( boost::ref(look) );
        else{
            this->CEGUI::Tree::setLookNFeel( boost::ref(look) );
        }
    }
    
    void default_setLookNFeel( ::CEGUI::String const & look ) {
        CEGUI::Tree::setLookNFeel( boost::ref(look) );
    }

    virtual void beginInitialisation(  ) {
        if( bp::override func_beginInitialisation = this->get_override( "beginInitialisation" ) )
            func_beginInitialisation(  );
        else{
            this->CEGUI::Window::beginInitialisation(  );
        }
    }
    
    void default_beginInitialisation(  ) {
        CEGUI::Window::beginInitialisation( );
    }

    virtual void cloneChildWidgetsTo( ::CEGUI::Window & target ) const  {
        if( bp::override func_cloneChildWidgetsTo = this->get_override( "cloneChildWidgetsTo" ) )
            func_cloneChildWidgetsTo( boost::ref(target) );
        else{
            this->CEGUI::Window::cloneChildWidgetsTo( boost::ref(target) );
        }
    }
    
    void default_cloneChildWidgetsTo( ::CEGUI::Window & target ) const  {
        CEGUI::Window::cloneChildWidgetsTo( boost::ref(target) );
    }

    virtual void clonePropertiesTo( ::CEGUI::Window & target ) const  {
        if( bp::override func_clonePropertiesTo = this->get_override( "clonePropertiesTo" ) )
            func_clonePropertiesTo( boost::ref(target) );
        else{
            this->CEGUI::Window::clonePropertiesTo( boost::ref(target) );
        }
    }
    
    void default_clonePropertiesTo( ::CEGUI::Window & target ) const  {
        CEGUI::Window::clonePropertiesTo( boost::ref(target) );
    }

    virtual void destroy(  ) {
        if( bp::override func_destroy = this->get_override( "destroy" ) )
            func_destroy(  );
        else{
            this->CEGUI::Window::destroy(  );
        }
    }
    
    void default_destroy(  ) {
        CEGUI::Window::destroy( );
    }

    virtual void endInitialisation(  ) {
        if( bp::override func_endInitialisation = this->get_override( "endInitialisation" ) )
            func_endInitialisation(  );
        else{
            this->CEGUI::Window::endInitialisation(  );
        }
    }
    
    void default_endInitialisation(  ) {
        CEGUI::Window::endInitialisation( );
    }

    virtual void fireEvent( ::CEGUI::String const & name, ::CEGUI::EventArgs & args, ::CEGUI::String const & eventNamespace="" ) {
        if( bp::override func_fireEvent = this->get_override( "fireEvent" ) )
            func_fireEvent( boost::ref(name), boost::ref(args), boost::ref(eventNamespace) );
        else{
            this->CEGUI::EventSet::fireEvent( boost::ref(name), boost::ref(args), boost::ref(eventNamespace) );
        }
    }
    
    void default_fireEvent( ::CEGUI::String const & name, ::CEGUI::EventArgs & args, ::CEGUI::String const & eventNamespace="" ) {
        CEGUI::EventSet::fireEvent( boost::ref(name), boost::ref(args), boost::ref(eventNamespace) );
    }

    virtual void getRenderingContext_impl( ::CEGUI::RenderingContext & ctx ) const  {
        if( bp::override func_getRenderingContext_impl = this->get_override( "getRenderingContext_impl" ) )
            func_getRenderingContext_impl( boost::ref(ctx) );
        else{
            this->CEGUI::Window::getRenderingContext_impl( boost::ref(ctx) );
        }
    }
    
    void default_getRenderingContext_impl( ::CEGUI::RenderingContext & ctx ) const  {
        CEGUI::Window::getRenderingContext_impl( boost::ref(ctx) );
    }

    virtual ::CEGUI::Rect getUnclippedInnerRect_impl(  ) const  {
        if( bp::override func_getUnclippedInnerRect_impl = this->get_override( "getUnclippedInnerRect_impl" ) )
            return func_getUnclippedInnerRect_impl(  );
        else{
            return this->CEGUI::Window::getUnclippedInnerRect_impl(  );
        }
    }
    
    ::CEGUI::Rect default_getUnclippedInnerRect_impl(  ) const  {
        return CEGUI::Window::getUnclippedInnerRect_impl( );
    }

    virtual void initialiseComponents(  ) {
        if( bp::override func_initialiseComponents = this->get_override( "initialiseComponents" ) )
            func_initialiseComponents(  );
        else{
            this->CEGUI::Window::initialiseComponents(  );
        }
    }
    
    void default_initialiseComponents(  ) {
        CEGUI::Window::initialiseComponents( );
    }

    virtual bool isHit( ::CEGUI::Vector2 const & position, bool const allow_disabled=false ) const  {
        if( bp::override func_isHit = this->get_override( "isHit" ) )
            return func_isHit( boost::ref(position), allow_disabled );
        else{
            return this->CEGUI::Window::isHit( boost::ref(position), allow_disabled );
        }
    }
    
    bool default_isHit( ::CEGUI::Vector2 const & position, bool const allow_disabled=false ) const  {
        return CEGUI::Window::isHit( boost::ref(position), allow_disabled );
    }

    virtual void performChildWindowLayout(  ) {
        if( bp::override func_performChildWindowLayout = this->get_override( "performChildWindowLayout" ) )
            func_performChildWindowLayout(  );
        else{
            this->CEGUI::Window::performChildWindowLayout(  );
        }
    }
    
    void default_performChildWindowLayout(  ) {
        CEGUI::Window::performChildWindowLayout( );
    }

    virtual void setMargin( ::CEGUI::UBox const & margin ) {
        if( bp::override func_setMargin = this->get_override( "setMargin" ) )
            func_setMargin( boost::ref(margin) );
        else{
            this->CEGUI::Window::setMargin( boost::ref(margin) );
        }
    }
    
    void default_setMargin( ::CEGUI::UBox const & margin ) {
        CEGUI::Window::setMargin( boost::ref(margin) );
    }

    virtual ::CEGUI::RefCounted< CEGUI::BoundSlot > subscribeScriptedEvent( ::CEGUI::String const & name, ::CEGUI::String const & subscriber_name ) {
        if( bp::override func_subscribeScriptedEvent = this->get_override( "subscribeScriptedEvent" ) )
            return func_subscribeScriptedEvent( boost::ref(name), boost::ref(subscriber_name) );
        else{
            return this->CEGUI::EventSet::subscribeScriptedEvent( boost::ref(name), boost::ref(subscriber_name) );
        }
    }
    
    ::CEGUI::RefCounted< CEGUI::BoundSlot > default_subscribeScriptedEvent( ::CEGUI::String const & name, ::CEGUI::String const & subscriber_name ) {
        return CEGUI::EventSet::subscribeScriptedEvent( boost::ref(name), boost::ref(subscriber_name) );
    }

    virtual ::CEGUI::RefCounted< CEGUI::BoundSlot > subscribeScriptedEvent( ::CEGUI::String const & name, unsigned int group, ::CEGUI::String const & subscriber_name ) {
        if( bp::override func_subscribeScriptedEvent = this->get_override( "subscribeScriptedEvent" ) )
            return func_subscribeScriptedEvent( boost::ref(name), group, boost::ref(subscriber_name) );
        else{
            return this->CEGUI::EventSet::subscribeScriptedEvent( boost::ref(name), group, boost::ref(subscriber_name) );
        }
    }
    
    ::CEGUI::RefCounted< CEGUI::BoundSlot > default_subscribeScriptedEvent( ::CEGUI::String const & name, unsigned int group, ::CEGUI::String const & subscriber_name ) {
        return CEGUI::EventSet::subscribeScriptedEvent( boost::ref(name), group, boost::ref(subscriber_name) );
    }

    virtual void update( float elapsed ) {
        if( bp::override func_update = this->get_override( "update" ) )
            func_update( elapsed );
        else{
            this->CEGUI::Window::update( elapsed );
        }
    }
    
    void default_update( float elapsed ) {
        CEGUI::Window::update( elapsed );
    }

    virtual void writeXMLToStream( ::CEGUI::XMLSerializer & xml_stream ) const  {
        if( bp::override func_writeXMLToStream = this->get_override( "writeXMLToStream" ) )
            func_writeXMLToStream( boost::ref(xml_stream) );
        else{
            this->CEGUI::Window::writeXMLToStream( boost::ref(xml_stream) );
        }
    }
    
    void default_writeXMLToStream( ::CEGUI::XMLSerializer & xml_stream ) const  {
        CEGUI::Window::writeXMLToStream( boost::ref(xml_stream) );
    }

};

void register_Tree_class(){

    { //::CEGUI::Tree
        typedef bp::class_< Tree_wrapper, bp::bases< CEGUI::Window >, boost::noncopyable > Tree_exposer_t;
        Tree_exposer_t Tree_exposer = Tree_exposer_t( "Tree", "*!\n\
         \n\
            Base class for standard Tree widget.\n\
        \n\
          deprecated\n\
            The CEGUI.Tree, CEGUI.TreeItem and any other associated classes are\n\
            deprecated and thier use should be minimised - preferably eliminated -\n\
            where possible.  It is extremely unfortunate that this widget was ever added\n\
            to CEGUI since its design and implementation are poor and do not meet \n\
            established standards for the CEGUI project.\n\
            \n\
            While no alternative currently exists, a superior, replacement tree widget\n\
            will be provided prior to the final removal of the current implementation.\n\
         *\n", bp::init< CEGUI::String const &, CEGUI::String const & >(( bp::arg("type"), bp::arg("name") ), "*************************************************************************\n\
         Construction and Destruction\n\
         *************************************************************************\n\
        *!\n\
         \n\
            Constructor for Tree base class.\n\
         *\n") );
        bp::scope Tree_scope( Tree_exposer );
        { //::CEGUI::Tree::addItem
        
            typedef void ( ::CEGUI::Tree::*addItem_function_type )( ::CEGUI::TreeItem * ) ;
            
            Tree_exposer.def( 
                "addItem"
                , addItem_function_type( &::CEGUI::Tree::addItem )
                , ( bp::arg("item") )
                , "*!\n\
             \n\
                Add the given TreeItem to the tree.\n\
             \n\
             @param item\n\
                 Pointer to the TreeItem to be added to the tree.  Note that it is the\n\
                 passed object that is added to the tree, a copy is not made.  If this\n\
                 parameter is NULL, nothing happens.\n\
             \n\
             @return\n\
                Nothing.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::clearAllSelections
        
            typedef void ( ::CEGUI::Tree::*clearAllSelections_function_type )(  ) ;
            
            Tree_exposer.def( 
                "clearAllSelections"
                , clearAllSelections_function_type( &::CEGUI::Tree::clearAllSelections )
                , "*!\n\
             \n\
                Clear the selected state for all items.\n\
             \n\
             @return\n\
                Nothing.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::clearAllSelectionsFromList
        
            typedef bool ( ::CEGUI::Tree::*clearAllSelectionsFromList_function_type )( ::std::vector< CEGUI::TreeItem* > const & ) ;
            
            Tree_exposer.def( 
                "clearAllSelectionsFromList"
                , clearAllSelectionsFromList_function_type( &::CEGUI::Tree::clearAllSelectionsFromList )
                , ( bp::arg("itemList") )
                , "*!\n\
             \n\
                Clear the selected state for all items.\n\
             \n\
             @return\n\
                Nothing.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::doScrollbars
        
            typedef void ( ::CEGUI::Tree::*doScrollbars_function_type )(  ) ;
            
            Tree_exposer.def( 
                "doScrollbars"
                , doScrollbars_function_type( &::CEGUI::Tree::doScrollbars )
                , "UpdateScrollbars\n" );
        
        }
        { //::CEGUI::Tree::doTreeRender
        
            typedef void ( ::CEGUI::Tree::*doTreeRender_function_type )(  ) ;
            
            Tree_exposer.def( 
                "doTreeRender"
                , doTreeRender_function_type( &::CEGUI::Tree::doTreeRender )
                , "Render the actual tree\n" );
        
        }
        { //::CEGUI::Tree::ensureItemIsVisible
        
            typedef void ( ::CEGUI::Tree::*ensureItemIsVisible_function_type )( ::CEGUI::TreeItem const * ) ;
            
            Tree_exposer.def( 
                "ensureItemIsVisible"
                , ensureItemIsVisible_function_type( &::CEGUI::Tree::ensureItemIsVisible )
                , ( bp::arg("item") )
                , "*!\n\
             \n\
                Ensure the item at the specified index is visible within the tree.\n\
             \n\
             @param item\n\
                Pointer to the TreeItem to be made visible in the tree.\n\
             \n\
             @return\n\
                Nothing.\n\
             \n\
             @exception   InvalidRequestException thrown if  item is not attached to\n\
                this tree.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::findFirstItemWithID
        
            typedef ::CEGUI::TreeItem * ( ::CEGUI::Tree::*findFirstItemWithID_function_type )( ::CEGUI::uint ) ;
            
            Tree_exposer.def( 
                "findFirstItemWithID"
                , findFirstItemWithID_function_type( &::CEGUI::Tree::findFirstItemWithID )
                , ( bp::arg("searchID") )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
             \n\
                Search the tree for an item with the specified text\n\
             \n\
             @param text\n\
                String object containing the text to be searched for.\n\
             \n\
             @param start_item\n\
                TreeItem where the search is to begin, the search will not include\n\
                 item.  If  item is 0, the search will begin from the first item in\n\
                the tree.\n\
             \n\
             @return\n\
                Pointer to the first TreeItem in the tree after  item that has text\n\
                matching  text.  If no item matches the criteria 0 is returned.\n\
             \n\
             @exception   InvalidRequestException thrown if  item is not attached to\n\
                this tree.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::findFirstItemWithText
        
            typedef ::CEGUI::TreeItem * ( ::CEGUI::Tree::*findFirstItemWithText_function_type )( ::CEGUI::String const & ) ;
            
            Tree_exposer.def( 
                "findFirstItemWithText"
                , findFirstItemWithText_function_type( &::CEGUI::Tree::findFirstItemWithText )
                , ( bp::arg("text") )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
             \n\
                Search the tree for an item with the specified text\n\
             \n\
             @param text\n\
                String object containing the text to be searched for.\n\
             \n\
             @param start_item\n\
                TreeItem where the search is to begin, the search will not include \n\
                item.  If  item is 0, the search will begin from the first item in\n\
                the tree.\n\
             \n\
             @return\n\
                Pointer to the first TreeItem in the tree after  item that has text\n\
                matching  text.  If no item matches the criteria, 0 is returned.\n\
             \n\
             @exception   InvalidRequestException thrown if  item is not attached to\n\
                this tree.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::findItemWithIDFromList
        
            typedef ::CEGUI::TreeItem * ( ::CEGUI::Tree::*findItemWithIDFromList_function_type )( ::std::vector< CEGUI::TreeItem* > const &,::CEGUI::uint,::CEGUI::TreeItem const *,bool ) ;
            
            Tree_exposer.def( 
                "findItemWithIDFromList"
                , findItemWithIDFromList_function_type( &::CEGUI::Tree::findItemWithIDFromList )
                , ( bp::arg("itemList"), bp::arg("searchID"), bp::arg("start_item"), bp::arg("foundStartItem") )
                , bp::return_value_policy< bp::reference_existing_object >() );
        
        }
        { //::CEGUI::Tree::findItemWithTextFromList
        
            typedef ::CEGUI::TreeItem * ( ::CEGUI::Tree::*findItemWithTextFromList_function_type )( ::std::vector< CEGUI::TreeItem* > const &,::CEGUI::String const &,::CEGUI::TreeItem const *,bool ) ;
            
            Tree_exposer.def( 
                "findItemWithTextFromList"
                , findItemWithTextFromList_function_type( &::CEGUI::Tree::findItemWithTextFromList )
                , ( bp::arg("itemList"), bp::arg("text"), bp::arg("start_item"), bp::arg("foundStartItem") )
                , bp::return_value_policy< bp::reference_existing_object >() );
        
        }
        { //::CEGUI::Tree::findNextItemWithID
        
            typedef ::CEGUI::TreeItem * ( ::CEGUI::Tree::*findNextItemWithID_function_type )( ::CEGUI::uint,::CEGUI::TreeItem const * ) ;
            
            Tree_exposer.def( 
                "findNextItemWithID"
                , findNextItemWithID_function_type( &::CEGUI::Tree::findNextItemWithID )
                , ( bp::arg("searchID"), bp::arg("start_item") )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
             \n\
                Search the tree for an item with the specified text\n\
             \n\
             @param text\n\
                String object containing the text to be searched for.\n\
             \n\
             @param start_item\n\
                TreeItem where the search is to begin, the search will not include\n\
                 item.  If  item is 0, the search will begin from the first item in\n\
                the tree.\n\
             \n\
             @return\n\
                Pointer to the first TreeItem in the tree after  item that has text\n\
                matching  text.  If no item matches the criteria 0 is returned.\n\
             \n\
             @exception   InvalidRequestException thrown if  item is not attached to\n\
                this tree.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::findNextItemWithText
        
            typedef ::CEGUI::TreeItem * ( ::CEGUI::Tree::*findNextItemWithText_function_type )( ::CEGUI::String const &,::CEGUI::TreeItem const * ) ;
            
            Tree_exposer.def( 
                "findNextItemWithText"
                , findNextItemWithText_function_type( &::CEGUI::Tree::findNextItemWithText )
                , ( bp::arg("text"), bp::arg("start_item") )
                , bp::return_value_policy< bp::reference_existing_object >() );
        
        }
        { //::CEGUI::Tree::getFirstSelectedItem
        
            typedef ::CEGUI::TreeItem * ( ::CEGUI::Tree::*getFirstSelectedItem_function_type )(  ) const;
            
            Tree_exposer.def( 
                "getFirstSelectedItem"
                , getFirstSelectedItem_function_type( &::CEGUI::Tree::getFirstSelectedItem )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
             \n\
                Return a pointer to the first selected item.\n\
             \n\
             @return\n\
                Pointer to a TreeItem based object that is the first selected item in\n\
                the tree.  will return 0 if no item is selected.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::getHorzScrollbar
        
            typedef ::CEGUI::Scrollbar * ( ::CEGUI::Tree::*getHorzScrollbar_function_type )(  ) ;
            
            Tree_exposer.def( 
                "getHorzScrollbar"
                , getHorzScrollbar_function_type( &::CEGUI::Tree::getHorzScrollbar )
                , bp::return_value_policy< bp::reference_existing_object >() );
        
        }
        { //::CEGUI::Tree::getItemCount
        
            typedef ::size_t ( ::CEGUI::Tree::*getItemCount_function_type )(  ) const;
            
            Tree_exposer.def( 
                "getItemCount"
                , getItemCount_function_type( &::CEGUI::Tree::getItemCount )
                , "*************************************************************************\n\
                Accessor Methods\n\
             *************************************************************************\n\
            *!\n\
             \n\
                Return number of items attached to the tree\n\
             \n\
             @return\n\
                the number of items currently attached to this tree.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::getLastSelectedItem
        
            typedef ::CEGUI::TreeItem * ( ::CEGUI::Tree::*getLastSelectedItem_function_type )(  ) const;
            
            Tree_exposer.def( 
                "getLastSelectedItem"
                , getLastSelectedItem_function_type( &::CEGUI::Tree::getLastSelectedItem )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
             \n\
                Return a pointer to the first selected item.\n\
             \n\
             @return\n\
                Pointer to a TreeItem based object that is the last item selected by the\n\
                user, not necessarily the last selected in the tree.  Will return 0 if\n\
                no item is selected.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::getNextSelected
        
            typedef ::CEGUI::TreeItem * ( ::CEGUI::Tree::*getNextSelected_function_type )( ::CEGUI::TreeItem const * ) const;
            
            Tree_exposer.def( 
                "getNextSelected"
                , getNextSelected_function_type( &::CEGUI::Tree::getNextSelected )
                , ( bp::arg("start_item") )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
             \n\
                Return a pointer to the next selected item after item  start_item\n\
             \n\
             @param start_item\n\
                 Pointer to the TreeItem where the search for the next selected item is\n\
                 to begin.  If this parameter is 0, the search will begin with the first\n\
                 item in the tree.\n\
             \n\
             @return\n\
                 Pointer to a TreeItem based object that is the next selected item in\n\
                 the tree after the item specified by  start_item.  Will return 0 if\n\
                 no further items were selected.\n\
             \n\
             @exception   InvalidRequestException thrown if  start_item is not attached\n\
                to this tree.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::getSelectedCount
        
            typedef ::size_t ( ::CEGUI::Tree::*getSelectedCount_function_type )(  ) const;
            
            Tree_exposer.def( 
                "getSelectedCount"
                , getSelectedCount_function_type( &::CEGUI::Tree::getSelectedCount )
                , "*!\n\
             \n\
                Return the number of selected items in the tree.\n\
             \n\
             @return\n\
                Total number of attached items that are in the selected state.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::getVertScrollbar
        
            typedef ::CEGUI::Scrollbar * ( ::CEGUI::Tree::*getVertScrollbar_function_type )(  ) ;
            
            Tree_exposer.def( 
                "getVertScrollbar"
                , getVertScrollbar_function_type( &::CEGUI::Tree::getVertScrollbar )
                , bp::return_value_policy< bp::reference_existing_object >() );
        
        }
        { //::CEGUI::Tree::handleUpdatedItemData
        
            typedef void ( ::CEGUI::Tree::*handleUpdatedItemData_function_type )(  ) ;
            
            Tree_exposer.def( 
                "handleUpdatedItemData"
                , handleUpdatedItemData_function_type( &::CEGUI::Tree::handleUpdatedItemData )
                , "*!\n\
             \n\
                Causes the tree to update it's internal state after changes have\n\
                been made to one or more attached TreeItem objects.\n\
             \n\
                Client code must call this whenever it has made any changes to TreeItem\n\
                objects already attached to the tree.  If you are just adding items,\n\
                or removed items to update them prior to re-adding them, there is no\n\
                need to call this method.\n\
             \n\
             @return\n\
                Nothing.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::initialise
        
            typedef void ( ::CEGUI::Tree::*initialise_function_type )(  ) ;
            typedef void ( Tree_wrapper::*default_initialise_function_type )(  ) ;
            
            Tree_exposer.def( 
                "initialise"
                , initialise_function_type(&::CEGUI::Tree::initialise)
                , default_initialise_function_type(&Tree_wrapper::default_initialise) );
        
        }
        { //::CEGUI::Tree::insertItem
        
            typedef void ( ::CEGUI::Tree::*insertItem_function_type )( ::CEGUI::TreeItem *,::CEGUI::TreeItem const * ) ;
            
            Tree_exposer.def( 
                "insertItem"
                , insertItem_function_type( &::CEGUI::Tree::insertItem )
                , ( bp::arg("item"), bp::arg("position") )
                , "*!\n\
             \n\
                Insert an item into the tree after a specified item already in the\n\
                tree.\n\
             \n\
                Note that if the tree is sorted, the item may not end up in the\n\
                requested position.\n\
             \n\
             @param item\n\
                 Pointer to the TreeItem to be inserted.  Note that it is the passed\n\
                 object that is added to the tree, a copy is not made.  If this\n\
                 parameter is 0, nothing happens.\n\
             \n\
             @param position\n\
                 Pointer to a TreeItem that  item is to be inserted after.  If this\n\
                 parameter is 0, the item is inserted at the start of the tree.\n\
             \n\
             @return\n\
                Nothing.\n\
             \n\
             @exception InvalidRequestException   thrown if no TreeItem  position is\n\
                attached to this tree.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::isHorzScrollbarAlwaysShown
        
            typedef bool ( ::CEGUI::Tree::*isHorzScrollbarAlwaysShown_function_type )(  ) const;
            
            Tree_exposer.def( 
                "isHorzScrollbarAlwaysShown"
                , isHorzScrollbarAlwaysShown_function_type( &::CEGUI::Tree::isHorzScrollbarAlwaysShown )
                , "*!\n\
             \n\
                Return whether the horizontal scroll bar is always shown.\n\
             \n\
             @return\n\
                 - true if the scroll bar will always be shown even if it is not required.\n\
                 - false if the scroll bar will only be shown when it is required.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::isItemTooltipsEnabled
        
            typedef bool ( ::CEGUI::Tree::*isItemTooltipsEnabled_function_type )(  ) const;
            
            Tree_exposer.def( 
                "isItemTooltipsEnabled"
                , isItemTooltipsEnabled_function_type( &::CEGUI::Tree::isItemTooltipsEnabled ) );
        
        }
        { //::CEGUI::Tree::isMultiselectEnabled
        
            typedef bool ( ::CEGUI::Tree::*isMultiselectEnabled_function_type )(  ) const;
            
            Tree_exposer.def( 
                "isMultiselectEnabled"
                , isMultiselectEnabled_function_type( &::CEGUI::Tree::isMultiselectEnabled )
                , "*!\n\
             \n\
                return whether multi-select is enabled\n\
             \n\
             @return\n\
                true if multi-select is enabled, false if multi-select is not enabled.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::isSortEnabled
        
            typedef bool ( ::CEGUI::Tree::*isSortEnabled_function_type )(  ) const;
            
            Tree_exposer.def( 
                "isSortEnabled"
                , isSortEnabled_function_type( &::CEGUI::Tree::isSortEnabled )
                , "*!\n\
             \n\
                return whether tree sorting is enabled\n\
             \n\
             @return\n\
                - true if the tree is sorted\n\
                - false if the tree is not sorted\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::isTreeItemInList
        
            typedef bool ( ::CEGUI::Tree::*isTreeItemInList_function_type )( ::CEGUI::TreeItem const * ) const;
            
            Tree_exposer.def( 
                "isTreeItemInList"
                , isTreeItemInList_function_type( &::CEGUI::Tree::isTreeItemInList )
                , ( bp::arg("item") )
                , "*!\n\
             \n\
                Return whether the specified TreeItem is in the tree\n\
             \n\
             @return\n\
                - true if TreeItem  item is in the tree\n\
                - false if TreeItem  item is not in the tree.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::isVertScrollbarAlwaysShown
        
            typedef bool ( ::CEGUI::Tree::*isVertScrollbarAlwaysShown_function_type )(  ) const;
            
            Tree_exposer.def( 
                "isVertScrollbarAlwaysShown"
                , isVertScrollbarAlwaysShown_function_type( &::CEGUI::Tree::isVertScrollbarAlwaysShown )
                , "*!\n\
             \n\
                Return whether the vertical scroll bar is always shown.\n\
             \n\
             @return\n\
                 - true if the scroll bar will always be shown even if it is not required.\n\
                 - false if the scroll bar will only be shown when it is required.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::removeItem
        
            typedef void ( ::CEGUI::Tree::*removeItem_function_type )( ::CEGUI::TreeItem const * ) ;
            
            Tree_exposer.def( 
                "removeItem"
                , removeItem_function_type( &::CEGUI::Tree::removeItem )
                , ( bp::arg("item") )
                , "*!\n\
             \n\
                Removes the given item from the tree.  If the item is has the auto\n\
                delete state set, the item will be deleted.\n\
             \n\
             @param item\n\
                Pointer to the TreeItem that is to be removed.  If  item is not\n\
                attached to this tree then nothing will happen.\n\
             \n\
             @return\n\
                Nothing.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::resetList
        
            typedef void ( ::CEGUI::Tree::*resetList_function_type )(  ) ;
            
            Tree_exposer.def( 
                "resetList"
                , resetList_function_type( &::CEGUI::Tree::resetList )
                , "*!\n\
             \n\
                Remove all items from the tree.\n\
             \n\
                Note that this will cause 'AutoDelete' items to be deleted.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::setItemRenderArea
        
            typedef void ( ::CEGUI::Tree::*setItemRenderArea_function_type )( ::CEGUI::Rect & ) ;
            
            Tree_exposer.def( 
                "setItemRenderArea"
                , setItemRenderArea_function_type( &::CEGUI::Tree::setItemRenderArea )
                , ( bp::arg("r") ) );
        
        }
        { //::CEGUI::Tree::setItemSelectState
        
            typedef void ( ::CEGUI::Tree::*setItemSelectState_function_type )( ::CEGUI::TreeItem *,bool ) ;
            
            Tree_exposer.def( 
                "setItemSelectState"
                , setItemSelectState_function_type( &::CEGUI::Tree::setItemSelectState )
                , ( bp::arg("item"), bp::arg("state") )
                , "*!\n\
             \n\
                Set the select state of an attached TreeItem.\n\
             \n\
                This is the recommended way of selecting and deselecting items attached\n\
                to a tree as it respects the multi-select mode setting.  It is\n\
                possible to modify the setting on TreeItems directly, but that approach\n\
                does not respect the settings of the tree.\n\
             \n\
             @param item\n\
                The TreeItem to be affected.\n\
                This item must be attached to the tree.\n\
             \n\
             @param state\n\
                - true to select the item.\n\
                - false to de-select the item.\n\
             \n\
             @return\n\
                Nothing.\n\
             \n\
             @exception   InvalidRequestException thrown if  item is not attached to\n\
                this tree.\n\
             *\n" );
        
        }
        { //::CEGUI::Tree::setItemSelectState
        
            typedef void ( ::CEGUI::Tree::*setItemSelectState_function_type )( ::size_t,bool ) ;
            
            Tree_exposer.def( 
                "setItemSelectState"
                , setItemSelectState_function_type( &::CEGUI::Tree::setItemSelectState )
                , ( bp::arg("item_index"), bp::arg("state") )
                , "*!\n\
                 \n\
                    Set the select state of an attached TreeItem.\n\
                 \n\
                    This is the recommended way of selecting and deselecting items attached\n\
                    to a tree as it respects the multi-select mode setting.  It is\n\
                    possible to modify the setting on TreeItems directly, but that approach\n\
                    does not respect the settings of the tree.\n\
                 \n\
                 @param item_index\n\
                    The zero based index of the TreeItem to be affected.\n\
                    This must be a valid index (0 <= index < getItemCount())\n\
            \n\
                 @param state\n\
                    - true to select the item.\n\
                    - false to de-select the item.\n\
                 \n\
                 @return\n\
                    Nothing.\n\
                 \n\
                 @exception   InvalidRequestException thrown if  item_index is out of range\n\
                    for the tree\n\
                 *\n" );
        
        }
        { //::CEGUI::Tree::setItemTooltipsEnabled
        
            typedef void ( ::CEGUI::Tree::*setItemTooltipsEnabled_function_type )( bool ) ;
            
            Tree_exposer.def( 
                "setItemTooltipsEnabled"
                , setItemTooltipsEnabled_function_type( &::CEGUI::Tree::setItemTooltipsEnabled )
                , ( bp::arg("setting") ) );
        
        }
        { //::CEGUI::Tree::setLookNFeel
        
            typedef void ( ::CEGUI::Tree::*setLookNFeel_function_type )( ::CEGUI::String const & ) ;
            typedef void ( Tree_wrapper::*default_setLookNFeel_function_type )( ::CEGUI::String const & ) ;
            
            Tree_exposer.def( 
                "setLookNFeel"
                , setLookNFeel_function_type(&::CEGUI::Tree::setLookNFeel)
                , default_setLookNFeel_function_type(&Tree_wrapper::default_setLookNFeel)
                , ( bp::arg("look") ) );
        
        }
        { //::CEGUI::Tree::setMultiselectEnabled
        
            typedef void ( ::CEGUI::Tree::*setMultiselectEnabled_function_type )( bool ) ;
            
            Tree_exposer.def( 
                "setMultiselectEnabled"
                , setMultiselectEnabled_function_type( &::CEGUI::Tree::setMultiselectEnabled )
                , ( bp::arg("setting") )
                , "*!\n\
                 \n\
                    Set whether the tree should allow multiple selections or just a single\n\
                    selection.\n\
                 \n\
                 @param  setting\n\
                     - true if the widget should allow multiple items to be selected\n\
                     - false if the widget should only allow a single selection.\n\
            \n\
                 @return\n\
                    Nothing.\n\
                 *\n" );
        
        }
        { //::CEGUI::Tree::setShowHorzScrollbar
        
            typedef void ( ::CEGUI::Tree::*setShowHorzScrollbar_function_type )( bool ) ;
            
            Tree_exposer.def( 
                "setShowHorzScrollbar"
                , setShowHorzScrollbar_function_type( &::CEGUI::Tree::setShowHorzScrollbar )
                , ( bp::arg("setting") )
                , "*!\n\
                 \n\
                    Set whether the horizontal scroll bar should always be shown.\n\
                 \n\
                 @param setting\n\
                     - true if the horizontal scroll bar should be shown even when it is not\n\
                       required.\n\
                     - false if the horizontal scroll bar should only be shown when it is\n\
                       required.\n\
            \n\
                 @return\n\
                    Nothing.\n\
                 *\n" );
        
        }
        { //::CEGUI::Tree::setShowVertScrollbar
        
            typedef void ( ::CEGUI::Tree::*setShowVertScrollbar_function_type )( bool ) ;
            
            Tree_exposer.def( 
                "setShowVertScrollbar"
                , setShowVertScrollbar_function_type( &::CEGUI::Tree::setShowVertScrollbar )
                , ( bp::arg("setting") )
                , "*!\n\
                 \n\
                    Set whether the vertical scroll bar should always be shown.\n\
                 \n\
                 @param setting\n\
                     - true if the vertical scroll bar should be shown even when it is not\n\
                       required.\n\
                     - false if the vertical scroll bar should only be shown when it is\n\
                       required.\n\
            \n\
                 @return\n\
                    Nothing.\n\
                 *\n" );
        
        }
        { //::CEGUI::Tree::setSortingEnabled
        
            typedef void ( ::CEGUI::Tree::*setSortingEnabled_function_type )( bool ) ;
            
            Tree_exposer.def( 
                "setSortingEnabled"
                , setSortingEnabled_function_type( &::CEGUI::Tree::setSortingEnabled )
                , ( bp::arg("setting") )
                , "*!\n\
             \n\
                Set whether the tree should be sorted.\n\
             \n\
             @param setting\n\
                - true if the tree should be sorted\n\
                - false if the tree should not be sorted.\n\
             \n\
             @return\n\
                Nothing.\n\
             *\n" );
        
        }
        Tree_exposer.add_static_property( "EventBranchClosed"
                        , bp::make_getter( &CEGUI::Tree::EventBranchClosed
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Tree_exposer.add_static_property( "EventBranchOpened"
                        , bp::make_getter( &CEGUI::Tree::EventBranchOpened
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Tree_exposer.add_static_property( "EventHorzScrollbarModeChanged"
                        , bp::make_getter( &CEGUI::Tree::EventHorzScrollbarModeChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Tree_exposer.add_static_property( "EventListContentsChanged"
                        , bp::make_getter( &CEGUI::Tree::EventListContentsChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Tree_exposer.add_static_property( "EventMultiselectModeChanged"
                        , bp::make_getter( &CEGUI::Tree::EventMultiselectModeChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Tree_exposer.add_static_property( "EventSelectionChanged"
                        , bp::make_getter( &CEGUI::Tree::EventSelectionChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Tree_exposer.add_static_property( "EventSortModeChanged"
                        , bp::make_getter( &CEGUI::Tree::EventSortModeChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Tree_exposer.add_static_property( "EventVertScrollbarModeChanged"
                        , bp::make_getter( &CEGUI::Tree::EventVertScrollbarModeChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        { //::CEGUI::Window::beginInitialisation
        
            typedef void ( ::CEGUI::Window::*beginInitialisation_function_type )(  ) ;
            typedef void ( Tree_wrapper::*default_beginInitialisation_function_type )(  ) ;
            
            Tree_exposer.def( 
                "beginInitialisation"
                , beginInitialisation_function_type(&::CEGUI::Window::beginInitialisation)
                , default_beginInitialisation_function_type(&Tree_wrapper::default_beginInitialisation) );
        
        }
        { //::CEGUI::Window::cloneChildWidgetsTo
        
            typedef void ( ::CEGUI::Window::*cloneChildWidgetsTo_function_type )( ::CEGUI::Window & ) const;
            typedef void ( Tree_wrapper::*default_cloneChildWidgetsTo_function_type )( ::CEGUI::Window & ) const;
            
            Tree_exposer.def( 
                "cloneChildWidgetsTo"
                , cloneChildWidgetsTo_function_type(&::CEGUI::Window::cloneChildWidgetsTo)
                , default_cloneChildWidgetsTo_function_type(&Tree_wrapper::default_cloneChildWidgetsTo)
                , ( bp::arg("target") ) );
        
        }
        { //::CEGUI::Window::clonePropertiesTo
        
            typedef void ( ::CEGUI::Window::*clonePropertiesTo_function_type )( ::CEGUI::Window & ) const;
            typedef void ( Tree_wrapper::*default_clonePropertiesTo_function_type )( ::CEGUI::Window & ) const;
            
            Tree_exposer.def( 
                "clonePropertiesTo"
                , clonePropertiesTo_function_type(&::CEGUI::Window::clonePropertiesTo)
                , default_clonePropertiesTo_function_type(&Tree_wrapper::default_clonePropertiesTo)
                , ( bp::arg("target") ) );
        
        }
        { //::CEGUI::Window::destroy
        
            typedef void ( ::CEGUI::Window::*destroy_function_type )(  ) ;
            typedef void ( Tree_wrapper::*default_destroy_function_type )(  ) ;
            
            Tree_exposer.def( 
                "destroy"
                , destroy_function_type(&::CEGUI::Window::destroy)
                , default_destroy_function_type(&Tree_wrapper::default_destroy) );
        
        }
        { //::CEGUI::Window::endInitialisation
        
            typedef void ( ::CEGUI::Window::*endInitialisation_function_type )(  ) ;
            typedef void ( Tree_wrapper::*default_endInitialisation_function_type )(  ) ;
            
            Tree_exposer.def( 
                "endInitialisation"
                , endInitialisation_function_type(&::CEGUI::Window::endInitialisation)
                , default_endInitialisation_function_type(&Tree_wrapper::default_endInitialisation) );
        
        }
        { //::CEGUI::EventSet::fireEvent
        
            typedef void ( ::CEGUI::EventSet::*fireEvent_function_type )( ::CEGUI::String const &,::CEGUI::EventArgs &,::CEGUI::String const & ) ;
            typedef void ( Tree_wrapper::*default_fireEvent_function_type )( ::CEGUI::String const &,::CEGUI::EventArgs &,::CEGUI::String const & ) ;
            
            Tree_exposer.def( 
                "fireEvent"
                , fireEvent_function_type(&::CEGUI::EventSet::fireEvent)
                , default_fireEvent_function_type(&Tree_wrapper::default_fireEvent)
                , ( bp::arg("name"), bp::arg("args"), bp::arg("eventNamespace")="" ) );
        
        }
        { //::CEGUI::Window::getRenderedStringParser
        
            typedef ::CEGUI::RenderedStringParser & ( ::CEGUI::Window::*getRenderedStringParser_function_type )(  ) const;
            
            Tree_exposer.def( 
                "getRenderedStringParser"
                , getRenderedStringParser_function_type(&::CEGUI::Window::getRenderedStringParser)
                , bp::return_value_policy< bp::reference_existing_object >() );
        
        }
        { //::CEGUI::Window::getRenderingContext_impl
        
            typedef void ( ::CEGUI::Window::*getRenderingContext_impl_function_type )( ::CEGUI::RenderingContext & ) const;
            typedef void ( Tree_wrapper::*default_getRenderingContext_impl_function_type )( ::CEGUI::RenderingContext & ) const;
            
            Tree_exposer.def( 
                "getRenderingContext_impl"
                , getRenderingContext_impl_function_type(&::CEGUI::Window::getRenderingContext_impl)
                , default_getRenderingContext_impl_function_type(&Tree_wrapper::default_getRenderingContext_impl)
                , ( bp::arg("ctx") ) );
        
        }
        { //::CEGUI::Window::getUnclippedInnerRect_impl
        
            typedef ::CEGUI::Rect ( ::CEGUI::Window::*getUnclippedInnerRect_impl_function_type )(  ) const;
            typedef ::CEGUI::Rect ( Tree_wrapper::*default_getUnclippedInnerRect_impl_function_type )(  ) const;
            
            Tree_exposer.def( 
                "getUnclippedInnerRect_impl"
                , getUnclippedInnerRect_impl_function_type(&::CEGUI::Window::getUnclippedInnerRect_impl)
                , default_getUnclippedInnerRect_impl_function_type(&Tree_wrapper::default_getUnclippedInnerRect_impl) );
        
        }
        { //::CEGUI::Window::initialiseComponents
        
            typedef void ( ::CEGUI::Window::*initialiseComponents_function_type )(  ) ;
            typedef void ( Tree_wrapper::*default_initialiseComponents_function_type )(  ) ;
            
            Tree_exposer.def( 
                "initialiseComponents"
                , initialiseComponents_function_type(&::CEGUI::Window::initialiseComponents)
                , default_initialiseComponents_function_type(&Tree_wrapper::default_initialiseComponents) );
        
        }
        { //::CEGUI::Window::isHit
        
            typedef bool ( ::CEGUI::Window::*isHit_function_type )( ::CEGUI::Vector2 const &,bool const ) const;
            typedef bool ( Tree_wrapper::*default_isHit_function_type )( ::CEGUI::Vector2 const &,bool const ) const;
            
            Tree_exposer.def( 
                "isHit"
                , isHit_function_type(&::CEGUI::Window::isHit)
                , default_isHit_function_type(&Tree_wrapper::default_isHit)
                , ( bp::arg("position"), bp::arg("allow_disabled")=(bool const)(false) ) );
        
        }
        { //::CEGUI::Window::performChildWindowLayout
        
            typedef void ( ::CEGUI::Window::*performChildWindowLayout_function_type )(  ) ;
            typedef void ( Tree_wrapper::*default_performChildWindowLayout_function_type )(  ) ;
            
            Tree_exposer.def( 
                "performChildWindowLayout"
                , performChildWindowLayout_function_type(&::CEGUI::Window::performChildWindowLayout)
                , default_performChildWindowLayout_function_type(&Tree_wrapper::default_performChildWindowLayout) );
        
        }
        { //::CEGUI::Window::setMargin
        
            typedef void ( ::CEGUI::Window::*setMargin_function_type )( ::CEGUI::UBox const & ) ;
            typedef void ( Tree_wrapper::*default_setMargin_function_type )( ::CEGUI::UBox const & ) ;
            
            Tree_exposer.def( 
                "setMargin"
                , setMargin_function_type(&::CEGUI::Window::setMargin)
                , default_setMargin_function_type(&Tree_wrapper::default_setMargin)
                , ( bp::arg("margin") ) );
        
        }
        { //::CEGUI::EventSet::subscribeScriptedEvent
        
            typedef ::CEGUI::RefCounted< CEGUI::BoundSlot > ( ::CEGUI::EventSet::*subscribeScriptedEvent_function_type )( ::CEGUI::String const &,::CEGUI::String const & ) ;
            typedef ::CEGUI::RefCounted< CEGUI::BoundSlot > ( Tree_wrapper::*default_subscribeScriptedEvent_function_type )( ::CEGUI::String const &,::CEGUI::String const & ) ;
            
            Tree_exposer.def( 
                "subscribeScriptedEvent"
                , subscribeScriptedEvent_function_type(&::CEGUI::EventSet::subscribeScriptedEvent)
                , default_subscribeScriptedEvent_function_type(&Tree_wrapper::default_subscribeScriptedEvent)
                , ( bp::arg("name"), bp::arg("subscriber_name") ) );
        
        }
        { //::CEGUI::EventSet::subscribeScriptedEvent
        
            typedef ::CEGUI::RefCounted< CEGUI::BoundSlot > ( ::CEGUI::EventSet::*subscribeScriptedEvent_function_type )( ::CEGUI::String const &,unsigned int,::CEGUI::String const & ) ;
            typedef ::CEGUI::RefCounted< CEGUI::BoundSlot > ( Tree_wrapper::*default_subscribeScriptedEvent_function_type )( ::CEGUI::String const &,unsigned int,::CEGUI::String const & ) ;
            
            Tree_exposer.def( 
                "subscribeScriptedEvent"
                , subscribeScriptedEvent_function_type(&::CEGUI::EventSet::subscribeScriptedEvent)
                , default_subscribeScriptedEvent_function_type(&Tree_wrapper::default_subscribeScriptedEvent)
                , ( bp::arg("name"), bp::arg("group"), bp::arg("subscriber_name") ) );
        
        }
        { //::CEGUI::Window::update
        
            typedef void ( ::CEGUI::Window::*update_function_type )( float ) ;
            typedef void ( Tree_wrapper::*default_update_function_type )( float ) ;
            
            Tree_exposer.def( 
                "update"
                , update_function_type(&::CEGUI::Window::update)
                , default_update_function_type(&Tree_wrapper::default_update)
                , ( bp::arg("elapsed") ) );
        
        }
        { //::CEGUI::Window::writeXMLToStream
        
            typedef void ( ::CEGUI::Window::*writeXMLToStream_function_type )( ::CEGUI::XMLSerializer & ) const;
            typedef void ( Tree_wrapper::*default_writeXMLToStream_function_type )( ::CEGUI::XMLSerializer & ) const;
            
            Tree_exposer.def( 
                "writeXMLToStream"
                , writeXMLToStream_function_type(&::CEGUI::Window::writeXMLToStream)
                , default_writeXMLToStream_function_type(&Tree_wrapper::default_writeXMLToStream)
                , ( bp::arg("xml_stream") ) );
        
        }
    }

}
