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

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

namespace bp = boost::python;

struct ItemListBase_wrapper : CEGUI::ItemListBase, bp::wrapper< CEGUI::ItemListBase > {

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

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

    virtual ::CEGUI::Size getContentSize(  ) const {
        bp::override func_getContentSize = this->get_override( "getContentSize" );
        return func_getContentSize(  );
    }

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

    virtual void layoutItemWidgets(  ){
        bp::override func_layoutItemWidgets = this->get_override( "layoutItemWidgets" );
        func_layoutItemWidgets(  );
    }

    virtual void notifyItemClicked( ::CEGUI::ItemEntry * arg0 ) {
        if( bp::override func_notifyItemClicked = this->get_override( "notifyItemClicked" ) )
            func_notifyItemClicked( boost::python::ptr(arg0) );
        else{
            this->CEGUI::ItemListBase::notifyItemClicked( boost::python::ptr(arg0) );
        }
    }
    
    void default_notifyItemClicked( ::CEGUI::ItemEntry * arg0 ) {
        CEGUI::ItemListBase::notifyItemClicked( boost::python::ptr(arg0) );
    }

    virtual void notifyItemSelectState( ::CEGUI::ItemEntry * arg0, bool arg1 ) {
        if( bp::override func_notifyItemSelectState = this->get_override( "notifyItemSelectState" ) )
            func_notifyItemSelectState( boost::python::ptr(arg0), arg1 );
        else{
            this->CEGUI::ItemListBase::notifyItemSelectState( boost::python::ptr(arg0), arg1 );
        }
    }
    
    void default_notifyItemSelectState( ::CEGUI::ItemEntry * arg0, bool arg1 ) {
        CEGUI::ItemListBase::notifyItemSelectState( boost::python::ptr(arg0), arg1 );
    }

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

    virtual void sizeToContent(  ) {
        if( bp::override func_sizeToContent = this->get_override( "sizeToContent" ) )
            func_sizeToContent(  );
        else{
            this->CEGUI::ItemListBase::sizeToContent(  );
        }
    }
    
    void default_sizeToContent(  ) {
        CEGUI::ItemListBase::sizeToContent( );
    }

    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 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 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 setLookNFeel( ::CEGUI::String const & look ) {
        if( bp::override func_setLookNFeel = this->get_override( "setLookNFeel" ) )
            func_setLookNFeel( boost::ref(look) );
        else{
            this->CEGUI::Window::setLookNFeel( boost::ref(look) );
        }
    }
    
    void default_setLookNFeel( ::CEGUI::String const & look ) {
        CEGUI::Window::setLookNFeel( boost::ref(look) );
    }

    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_ItemListBase_class(){

    { //::CEGUI::ItemListBase
        typedef bp::class_< ItemListBase_wrapper, bp::bases< CEGUI::Window >, boost::noncopyable > ItemListBase_exposer_t;
        ItemListBase_exposer_t ItemListBase_exposer = ItemListBase_exposer_t( "ItemListBase", "*!\n\
        \n\
           Base class for item list widgets.\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 ItemListBase base class.\n\
        *\n") );
        bp::scope ItemListBase_scope( ItemListBase_exposer );
        bp::enum_< CEGUI::ItemListBase::SortMode>("SortMode")
            .value("Ascending", CEGUI::ItemListBase::Ascending)
            .value("Descending", CEGUI::ItemListBase::Descending)
            .value("UserSort", CEGUI::ItemListBase::UserSort)
            .export_values()
            ;
        { //::CEGUI::ItemListBase::addItem
        
            typedef void ( ::CEGUI::ItemListBase::*addItem_function_type )( ::CEGUI::ItemEntry * ) ;
            
            ItemListBase_exposer.def( 
                "addItem"
                , addItem_function_type( &::CEGUI::ItemListBase::addItem )
                , ( bp::arg("item") )
                , "*!\n\
               \n\
                  Add the given ItemEntry to the list.\n\
            \n\
               @param item\n\
                  Pointer to the ItemEntry to be added to the list.  Note that it is the passed object that is\
                  added to the\n\
                  list, a copy is not made.  If this parameter is NULL, nothing happens.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::ItemListBase::endInitialisation
        
            typedef void ( ::CEGUI::ItemListBase::*endInitialisation_function_type )(  ) ;
            typedef void ( ItemListBase_wrapper::*default_endInitialisation_function_type )(  ) ;
            
            ItemListBase_exposer.def( 
                "endInitialisation"
                , endInitialisation_function_type(&::CEGUI::ItemListBase::endInitialisation)
                , default_endInitialisation_function_type(&ItemListBase_wrapper::default_endInitialisation) );
        
        }
        { //::CEGUI::ItemListBase::findItemWithText
        
            typedef ::CEGUI::ItemEntry * ( ::CEGUI::ItemListBase::*findItemWithText_function_type )( ::CEGUI::String const &,::CEGUI::ItemEntry const * ) ;
            
            ItemListBase_exposer.def( 
                "findItemWithText"
                , findItemWithText_function_type( &::CEGUI::ItemListBase::findItemWithText )
                , ( bp::arg("text"), bp::arg("start_item") )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
               \n\
                  Search the list 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\
                  ItemEntry where the search is to begin, the search will not include  item.  If  item is\n\
                  NULL, the search will begin from the first item in the list.\n\
            \n\
               @return\n\
                  Pointer to the first ItemEntry in the list after  item that has text matching  text.  If\n\
                  no item matches the criteria NULL is returned.\n\
            \n\
               @exception  InvalidRequestException thrown if  item is not attached to this list box.\n\
               *\n" );
        
        }
        { //::CEGUI::ItemListBase::getContentPane
        
            typedef ::CEGUI::Window * ( ::CEGUI::ItemListBase::*getContentPane_function_type )(  ) const;
            
            ItemListBase_exposer.def( 
                "getContentPane"
                , getContentPane_function_type( &::CEGUI::ItemListBase::getContentPane )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
            \n\
                Returns a pointer to the window that all items are directed too.\n\
                \n\
            @return\n\
                A pointer to the content pane window, or 'this' if children are added\n\
                directly to this window.\n\
            *\n" );
        
        }
        { //::CEGUI::ItemListBase::getContentSize
        
            typedef ::CEGUI::Size ( ItemListBase_wrapper::*getContentSize_function_type )(  ) const;
            
            ItemListBase_exposer.def( 
                "getContentSize"
                , getContentSize_function_type( &ItemListBase_wrapper::getContentSize )
                , "*!\n\
               \n\
                  Returns the Size in unclipped pixels of the content attached to this ItemListBase that is\
                  attached to it.\n\
            \n\
               @return\n\
                  Size object describing in unclipped pixels the size of the content ItemEntries attached to\
                  this menu.\n\
               *\n" );
        
        }
        { //::CEGUI::ItemListBase::getItemCount
        
            typedef ::size_t ( ::CEGUI::ItemListBase::*getItemCount_function_type )(  ) const;
            
            ItemListBase_exposer.def( 
                "getItemCount"
                , getItemCount_function_type( &::CEGUI::ItemListBase::getItemCount )
                , "*************************************************************************\n\
                  Accessor Methods\n\
               *************************************************************************\n\
               *!\n\
               \n\
                  Return number of items attached to the list\n\
            \n\
               @return\n\
                  the number of items currently attached to this list.\n\
               *\n" );
        
        }
        { //::CEGUI::ItemListBase::getItemFromIndex
        
            typedef ::CEGUI::ItemEntry * ( ::CEGUI::ItemListBase::*getItemFromIndex_function_type )( ::size_t ) const;
            
            ItemListBase_exposer.def( 
                "getItemFromIndex"
                , getItemFromIndex_function_type( &::CEGUI::ItemListBase::getItemFromIndex )
                , ( bp::arg("index") )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
               \n\
                  Return the item at index position  index.\n\
            \n\
               @param index\n\
                  Zero based index of the item to be returned.\n\
            \n\
               @return\n\
                  Pointer to the ItemEntry at index position  index in the list.\n\
            \n\
               @exception  InvalidRequestException thrown if  index is out of range.\n\
               *\n" );
        
        }
        { //::CEGUI::ItemListBase::getItemIndex
        
            typedef ::size_t ( ::CEGUI::ItemListBase::*getItemIndex_function_type )( ::CEGUI::ItemEntry const * ) const;
            
            ItemListBase_exposer.def( 
                "getItemIndex"
                , getItemIndex_function_type( &::CEGUI::ItemListBase::getItemIndex )
                , ( bp::arg("item") )
                , "*!\n\
               \n\
                  Return the index of ItemEntry  item\n\
            \n\
               @param item\n\
                  Pointer to a ItemEntry whos zero based index is to be returned.\n\
            \n\
               @return\n\
                  Zero based index indicating the position of ItemEntry  item in the list.\n\
            \n\
               @exception  InvalidRequestException thrown if  item is not attached to this list.\n\
               *\n" );
        
        }
        { //::CEGUI::ItemListBase::getItemRenderArea
        
            typedef ::CEGUI::Rect ( ::CEGUI::ItemListBase::*getItemRenderArea_function_type )(  ) const;
            
            ItemListBase_exposer.def( 
                "getItemRenderArea"
                , getItemRenderArea_function_type( &::CEGUI::ItemListBase::getItemRenderArea )
                , "*!\n\
                \n\
                    Return a Rect object describing, in un-clipped pixels, the window relative area\n\
                    that is to be used for rendering list items.\n\
            \n\
                @return\n\
                    Rect object describing the window relative area of the that is to be used for rendering\n\
                    the items.\n\
                *\n" );
        
        }
        { //::CEGUI::ItemListBase::getSortMode
        
            typedef ::CEGUI::ItemListBase::SortMode ( ::CEGUI::ItemListBase::*getSortMode_function_type )(  ) const;
            
            ItemListBase_exposer.def( 
                "getSortMode"
                , getSortMode_function_type( &::CEGUI::ItemListBase::getSortMode )
                , "*!\n\
            \n\
                Get sort mode.\n\
            *\n" );
        
        }
        { //::CEGUI::ItemListBase::handleUpdatedItemData
        
            typedef void ( ::CEGUI::ItemListBase::*handleUpdatedItemData_function_type )( bool ) ;
            
            ItemListBase_exposer.def( 
                "handleUpdatedItemData"
                , handleUpdatedItemData_function_type( &::CEGUI::ItemListBase::handleUpdatedItemData )
                , ( bp::arg("resort")=(bool)(false) )
                , "*!\n\
               \n\
                  Causes the list to update it's internal state after changes have been made to one or more\n\
                  attached ItemEntry objects.\n\
            \n\
                  It should not be necessary to call this from client code, as the ItemEntries themselves call\
                  it if their parent is an ItemListBase.\n\
            \n\
                @param resort\n\
                    'true' to redo the list sorting as well.\n\
                    'false' to only do layout and perhaps auto resize.\n\
                    (defaults to 'false')\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::ItemListBase::initialiseComponents
        
            typedef void ( ::CEGUI::ItemListBase::*initialiseComponents_function_type )(  ) ;
            typedef void ( ItemListBase_wrapper::*default_initialiseComponents_function_type )(  ) ;
            
            ItemListBase_exposer.def( 
                "initialiseComponents"
                , initialiseComponents_function_type(&::CEGUI::ItemListBase::initialiseComponents)
                , default_initialiseComponents_function_type(&ItemListBase_wrapper::default_initialiseComponents) );
        
        }
        { //::CEGUI::ItemListBase::insertItem
        
            typedef void ( ::CEGUI::ItemListBase::*insertItem_function_type )( ::CEGUI::ItemEntry *,::CEGUI::ItemEntry const * ) ;
            
            ItemListBase_exposer.def( 
                "insertItem"
                , insertItem_function_type( &::CEGUI::ItemListBase::insertItem )
                , ( bp::arg("item"), bp::arg("position") )
                , "*!\n\
               \n\
                  Insert an item into the list before a specified item already in the list.\n\
            \n\
                  Note that if the list is sorted, the item may not end up in the\n\
                    requested position.\n\
            \n\
               @param item\n\
                  Pointer to the ItemEntry to be inserted.  Note that it is the passed\n\
                    object that is added to the list, a copy is not made.  If this parameter\n\
                    is NULL, nothing happens.\n\
            \n\
               @param position\n\
                  Pointer to a ItemEntry that  item is to be inserted before.  If this\n\
                    parameter is NULL, the item is inserted at the start of the list.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::ItemListBase::isAutoResizeEnabled
        
            typedef bool ( ::CEGUI::ItemListBase::*isAutoResizeEnabled_function_type )(  ) const;
            
            ItemListBase_exposer.def( 
                "isAutoResizeEnabled"
                , isAutoResizeEnabled_function_type( &::CEGUI::ItemListBase::isAutoResizeEnabled )
                , "*!\n\
               \n\
                  Return whether this window is automatically resized to fit its content.\n\
            \n\
               @return\n\
                  true if automatic resizing is enabled, false if it is disabled.\n\
               *\n" );
        
        }
        { //::CEGUI::ItemListBase::isItemInList
        
            typedef bool ( ::CEGUI::ItemListBase::*isItemInList_function_type )( ::CEGUI::ItemEntry const * ) const;
            
            ItemListBase_exposer.def( 
                "isItemInList"
                , isItemInList_function_type( &::CEGUI::ItemListBase::isItemInList )
                , ( bp::arg("item") )
                , "*!\n\
               \n\
                  Return whether the specified ItemEntry is in the List\n\
            \n\
               @return\n\
                  true if ItemEntry  item is in the list, false if ItemEntry  item is not in the list.\n\
               *\n" );
        
        }
        { //::CEGUI::ItemListBase::isSortEnabled
        
            typedef bool ( ::CEGUI::ItemListBase::*isSortEnabled_function_type )(  ) const;
            
            ItemListBase_exposer.def( 
                "isSortEnabled"
                , isSortEnabled_function_type( &::CEGUI::ItemListBase::isSortEnabled )
                , "*!\n\
            \n\
                Returns 'true' if the list is sorted\n\
            *\n" );
        
        }
        { //::CEGUI::ItemListBase::layoutItemWidgets
        
            typedef void ( ItemListBase_wrapper::*layoutItemWidgets_function_type )(  ) ;
            
            ItemListBase_exposer.def( 
                "layoutItemWidgets"
                , layoutItemWidgets_function_type( &ItemListBase_wrapper::layoutItemWidgets )
                , "*!\n\
               \n\
                  Setup size and position for the item widgets attached to this ItemListBase\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::ItemListBase::notifyItemClicked
        
            typedef void ( ::CEGUI::ItemListBase::*notifyItemClicked_function_type )( ::CEGUI::ItemEntry * ) ;
            typedef void ( ItemListBase_wrapper::*default_notifyItemClicked_function_type )( ::CEGUI::ItemEntry * ) ;
            
            ItemListBase_exposer.def( 
                "notifyItemClicked"
                , notifyItemClicked_function_type(&::CEGUI::ItemListBase::notifyItemClicked)
                , default_notifyItemClicked_function_type(&ItemListBase_wrapper::default_notifyItemClicked)
                , ( bp::arg("arg0") ) );
        
        }
        { //::CEGUI::ItemListBase::notifyItemSelectState
        
            typedef void ( ::CEGUI::ItemListBase::*notifyItemSelectState_function_type )( ::CEGUI::ItemEntry *,bool ) ;
            typedef void ( ItemListBase_wrapper::*default_notifyItemSelectState_function_type )( ::CEGUI::ItemEntry *,bool ) ;
            
            ItemListBase_exposer.def( 
                "notifyItemSelectState"
                , notifyItemSelectState_function_type(&::CEGUI::ItemListBase::notifyItemSelectState)
                , default_notifyItemSelectState_function_type(&ItemListBase_wrapper::default_notifyItemSelectState)
                , ( bp::arg("arg0"), bp::arg("arg1") ) );
        
        }
        { //::CEGUI::ItemListBase::performChildWindowLayout
        
            typedef void ( ::CEGUI::ItemListBase::*performChildWindowLayout_function_type )(  ) ;
            typedef void ( ItemListBase_wrapper::*default_performChildWindowLayout_function_type )(  ) ;
            
            ItemListBase_exposer.def( 
                "performChildWindowLayout"
                , performChildWindowLayout_function_type(&::CEGUI::ItemListBase::performChildWindowLayout)
                , default_performChildWindowLayout_function_type(&ItemListBase_wrapper::default_performChildWindowLayout) );
        
        }
        { //::CEGUI::ItemListBase::removeItem
        
            typedef void ( ::CEGUI::ItemListBase::*removeItem_function_type )( ::CEGUI::ItemEntry * ) ;
            
            ItemListBase_exposer.def( 
                "removeItem"
                , removeItem_function_type( &::CEGUI::ItemListBase::removeItem )
                , ( bp::arg("item") )
                , "*!\n\
               \n\
                  Removes the given item from the list.  If the item is has the 'DestroyedByParent' property set\
                  to 'true', the item will be deleted.\n\
            \n\
               @param item\n\
                  Pointer to the ItemEntry that is to be removed.  If  item is not attached to this list then\
                  nothing\n\
                  will happen.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::ItemListBase::resetList
        
            typedef void ( ::CEGUI::ItemListBase::*resetList_function_type )(  ) ;
            
            ItemListBase_exposer.def( 
                "resetList"
                , resetList_function_type( &::CEGUI::ItemListBase::resetList )
                , "*!\n\
               \n\
                  Remove all items from the list.\n\
            \n\
                  Note that this will cause items, which does not have the 'DestroyedByParent' property set to\
                  'false', to be deleted.\n\
               *\n" );
        
        }
        { //::CEGUI::ItemListBase::setAutoResizeEnabled
        
            typedef void ( ::CEGUI::ItemListBase::*setAutoResizeEnabled_function_type )( bool ) ;
            
            ItemListBase_exposer.def( 
                "setAutoResizeEnabled"
                , setAutoResizeEnabled_function_type( &::CEGUI::ItemListBase::setAutoResizeEnabled )
                , ( bp::arg("setting") )
                , "*!\n\
               \n\
                  Set whether or not this ItemListBase widget should automatically resize to fit its content.\n\
            \n\
               @param setting\n\
                  Boolean value that if true enables automatic resizing, if false disables automatic resizing.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::ItemListBase::setSortEnabled
        
            typedef void ( ::CEGUI::ItemListBase::*setSortEnabled_function_type )( bool ) ;
            
            ItemListBase_exposer.def( 
                "setSortEnabled"
                , setSortEnabled_function_type( &::CEGUI::ItemListBase::setSortEnabled )
                , ( bp::arg("setting") )
                , "*!\n\
            \n\
                Set whether the list should be sorted (by text).\n\
            *\n" );
        
        }
        { //::CEGUI::ItemListBase::setSortMode
        
            typedef void ( ::CEGUI::ItemListBase::*setSortMode_function_type )( ::CEGUI::ItemListBase::SortMode ) ;
            
            ItemListBase_exposer.def( 
                "setSortMode"
                , setSortMode_function_type( &::CEGUI::ItemListBase::setSortMode )
                , ( bp::arg("mode") )
                , "*!\n\
            \n\
                Set mode to be used when sorting the list.\n\
            @param mode\n\
                SortMode enum.\n\
            *\n" );
        
        }
        { //::CEGUI::ItemListBase::sizeToContent
        
            typedef void ( ::CEGUI::ItemListBase::*sizeToContent_function_type )(  ) ;
            typedef void ( ItemListBase_wrapper::*default_sizeToContent_function_type )(  ) ;
            
            ItemListBase_exposer.def( 
                "sizeToContent"
                , sizeToContent_function_type(&::CEGUI::ItemListBase::sizeToContent)
                , default_sizeToContent_function_type(&ItemListBase_wrapper::default_sizeToContent) );
        
        }
        { //::CEGUI::ItemListBase::sortList
        
            typedef void ( ::CEGUI::ItemListBase::*sortList_function_type )( bool ) ;
            
            ItemListBase_exposer.def( 
                "sortList"
                , sortList_function_type( &::CEGUI::ItemListBase::sortList )
                , ( bp::arg("relayout")=(bool)(true) )
                , "*!\n\
                \n\
                    Sort the list.\n\
            \n\
                @param relayout\n\
                    True if the item layout should be redone after the sorting.\n\
                    False to only sort the internal list. Nothing more.\n\
            \n\
                    This parameter defaults to true and should generally not be\n\
                    used in client code.\n\
                *\n" );
        
        }
        ItemListBase_exposer.add_static_property( "EventListContentsChanged"
                        , bp::make_getter( &CEGUI::ItemListBase::EventListContentsChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        ItemListBase_exposer.add_static_property( "EventSortEnabledChanged"
                        , bp::make_getter( &CEGUI::ItemListBase::EventSortEnabledChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        ItemListBase_exposer.add_static_property( "EventSortModeChanged"
                        , bp::make_getter( &CEGUI::ItemListBase::EventSortModeChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        { //::CEGUI::Window::beginInitialisation
        
            typedef void ( ::CEGUI::Window::*beginInitialisation_function_type )(  ) ;
            typedef void ( ItemListBase_wrapper::*default_beginInitialisation_function_type )(  ) ;
            
            ItemListBase_exposer.def( 
                "beginInitialisation"
                , beginInitialisation_function_type(&::CEGUI::Window::beginInitialisation)
                , default_beginInitialisation_function_type(&ItemListBase_wrapper::default_beginInitialisation) );
        
        }
        { //::CEGUI::Window::cloneChildWidgetsTo
        
            typedef void ( ::CEGUI::Window::*cloneChildWidgetsTo_function_type )( ::CEGUI::Window & ) const;
            typedef void ( ItemListBase_wrapper::*default_cloneChildWidgetsTo_function_type )( ::CEGUI::Window & ) const;
            
            ItemListBase_exposer.def( 
                "cloneChildWidgetsTo"
                , cloneChildWidgetsTo_function_type(&::CEGUI::Window::cloneChildWidgetsTo)
                , default_cloneChildWidgetsTo_function_type(&ItemListBase_wrapper::default_cloneChildWidgetsTo)
                , ( bp::arg("target") ) );
        
        }
        { //::CEGUI::Window::clonePropertiesTo
        
            typedef void ( ::CEGUI::Window::*clonePropertiesTo_function_type )( ::CEGUI::Window & ) const;
            typedef void ( ItemListBase_wrapper::*default_clonePropertiesTo_function_type )( ::CEGUI::Window & ) const;
            
            ItemListBase_exposer.def( 
                "clonePropertiesTo"
                , clonePropertiesTo_function_type(&::CEGUI::Window::clonePropertiesTo)
                , default_clonePropertiesTo_function_type(&ItemListBase_wrapper::default_clonePropertiesTo)
                , ( bp::arg("target") ) );
        
        }
        { //::CEGUI::Window::destroy
        
            typedef void ( ::CEGUI::Window::*destroy_function_type )(  ) ;
            typedef void ( ItemListBase_wrapper::*default_destroy_function_type )(  ) ;
            
            ItemListBase_exposer.def( 
                "destroy"
                , destroy_function_type(&::CEGUI::Window::destroy)
                , default_destroy_function_type(&ItemListBase_wrapper::default_destroy) );
        
        }
        { //::CEGUI::EventSet::fireEvent
        
            typedef void ( ::CEGUI::EventSet::*fireEvent_function_type )( ::CEGUI::String const &,::CEGUI::EventArgs &,::CEGUI::String const & ) ;
            typedef void ( ItemListBase_wrapper::*default_fireEvent_function_type )( ::CEGUI::String const &,::CEGUI::EventArgs &,::CEGUI::String const & ) ;
            
            ItemListBase_exposer.def( 
                "fireEvent"
                , fireEvent_function_type(&::CEGUI::EventSet::fireEvent)
                , default_fireEvent_function_type(&ItemListBase_wrapper::default_fireEvent)
                , ( bp::arg("name"), bp::arg("args"), bp::arg("eventNamespace")="" ) );
        
        }
        { //::CEGUI::Window::getRenderedStringParser
        
            typedef ::CEGUI::RenderedStringParser & ( ::CEGUI::Window::*getRenderedStringParser_function_type )(  ) const;
            
            ItemListBase_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 ( ItemListBase_wrapper::*default_getRenderingContext_impl_function_type )( ::CEGUI::RenderingContext & ) const;
            
            ItemListBase_exposer.def( 
                "getRenderingContext_impl"
                , getRenderingContext_impl_function_type(&::CEGUI::Window::getRenderingContext_impl)
                , default_getRenderingContext_impl_function_type(&ItemListBase_wrapper::default_getRenderingContext_impl)
                , ( bp::arg("ctx") ) );
        
        }
        { //::CEGUI::Window::getUnclippedInnerRect_impl
        
            typedef ::CEGUI::Rect ( ::CEGUI::Window::*getUnclippedInnerRect_impl_function_type )(  ) const;
            typedef ::CEGUI::Rect ( ItemListBase_wrapper::*default_getUnclippedInnerRect_impl_function_type )(  ) const;
            
            ItemListBase_exposer.def( 
                "getUnclippedInnerRect_impl"
                , getUnclippedInnerRect_impl_function_type(&::CEGUI::Window::getUnclippedInnerRect_impl)
                , default_getUnclippedInnerRect_impl_function_type(&ItemListBase_wrapper::default_getUnclippedInnerRect_impl) );
        
        }
        { //::CEGUI::Window::isHit
        
            typedef bool ( ::CEGUI::Window::*isHit_function_type )( ::CEGUI::Vector2 const &,bool const ) const;
            typedef bool ( ItemListBase_wrapper::*default_isHit_function_type )( ::CEGUI::Vector2 const &,bool const ) const;
            
            ItemListBase_exposer.def( 
                "isHit"
                , isHit_function_type(&::CEGUI::Window::isHit)
                , default_isHit_function_type(&ItemListBase_wrapper::default_isHit)
                , ( bp::arg("position"), bp::arg("allow_disabled")=(bool const)(false) ) );
        
        }
        { //::CEGUI::Window::setLookNFeel
        
            typedef void ( ::CEGUI::Window::*setLookNFeel_function_type )( ::CEGUI::String const & ) ;
            typedef void ( ItemListBase_wrapper::*default_setLookNFeel_function_type )( ::CEGUI::String const & ) ;
            
            ItemListBase_exposer.def( 
                "setLookNFeel"
                , setLookNFeel_function_type(&::CEGUI::Window::setLookNFeel)
                , default_setLookNFeel_function_type(&ItemListBase_wrapper::default_setLookNFeel)
                , ( bp::arg("look") ) );
        
        }
        { //::CEGUI::Window::setMargin
        
            typedef void ( ::CEGUI::Window::*setMargin_function_type )( ::CEGUI::UBox const & ) ;
            typedef void ( ItemListBase_wrapper::*default_setMargin_function_type )( ::CEGUI::UBox const & ) ;
            
            ItemListBase_exposer.def( 
                "setMargin"
                , setMargin_function_type(&::CEGUI::Window::setMargin)
                , default_setMargin_function_type(&ItemListBase_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 > ( ItemListBase_wrapper::*default_subscribeScriptedEvent_function_type )( ::CEGUI::String const &,::CEGUI::String const & ) ;
            
            ItemListBase_exposer.def( 
                "subscribeScriptedEvent"
                , subscribeScriptedEvent_function_type(&::CEGUI::EventSet::subscribeScriptedEvent)
                , default_subscribeScriptedEvent_function_type(&ItemListBase_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 > ( ItemListBase_wrapper::*default_subscribeScriptedEvent_function_type )( ::CEGUI::String const &,unsigned int,::CEGUI::String const & ) ;
            
            ItemListBase_exposer.def( 
                "subscribeScriptedEvent"
                , subscribeScriptedEvent_function_type(&::CEGUI::EventSet::subscribeScriptedEvent)
                , default_subscribeScriptedEvent_function_type(&ItemListBase_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 ( ItemListBase_wrapper::*default_update_function_type )( float ) ;
            
            ItemListBase_exposer.def( 
                "update"
                , update_function_type(&::CEGUI::Window::update)
                , default_update_function_type(&ItemListBase_wrapper::default_update)
                , ( bp::arg("elapsed") ) );
        
        }
        { //::CEGUI::Window::writeXMLToStream
        
            typedef void ( ::CEGUI::Window::*writeXMLToStream_function_type )( ::CEGUI::XMLSerializer & ) const;
            typedef void ( ItemListBase_wrapper::*default_writeXMLToStream_function_type )( ::CEGUI::XMLSerializer & ) const;
            
            ItemListBase_exposer.def( 
                "writeXMLToStream"
                , writeXMLToStream_function_type(&::CEGUI::Window::writeXMLToStream)
                , default_writeXMLToStream_function_type(&ItemListBase_wrapper::default_writeXMLToStream)
                , ( bp::arg("xml_stream") ) );
        
        }
    }

}
