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

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

namespace bp = boost::python;

struct Listbox_wrapper : CEGUI::Listbox, bp::wrapper< CEGUI::Listbox > {

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

    virtual ::CEGUI::Rect getListRenderArea(  ) const  {
        if( bp::override func_getListRenderArea = this->get_override( "getListRenderArea" ) )
            return func_getListRenderArea(  );
        else{
            return this->CEGUI::Listbox::getListRenderArea(  );
        }
    }
    
    ::CEGUI::Rect default_getListRenderArea(  ) const  {
        return CEGUI::Listbox::getListRenderArea( );
    }

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

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

    { //::CEGUI::Listbox
        typedef bp::class_< Listbox_wrapper, bp::bases< CEGUI::Window >, boost::noncopyable > Listbox_exposer_t;
        Listbox_exposer_t Listbox_exposer = Listbox_exposer_t( "Listbox", "*!\n\
        \n\
           Base class for standard Listbox widget.\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 Listbox base class.\n\
        *\n") );
        bp::scope Listbox_scope( Listbox_exposer );
        { //::CEGUI::Listbox::addItem
        
            typedef void ( ::CEGUI::Listbox::*addItem_function_type )( ::CEGUI::ListboxItem * ) ;
            
            Listbox_exposer.def( 
                "addItem"
                , addItem_function_type( &::CEGUI::Listbox::addItem )
                , ( bp::arg("item") )
                , "*!\n\
               \n\
                  Add the given ListboxItem to the list.\n\
            \n\
               @param item\n\
                  Pointer to the ListboxItem 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::Listbox::clearAllSelections
        
            typedef void ( ::CEGUI::Listbox::*clearAllSelections_function_type )(  ) ;
            
            Listbox_exposer.def( 
                "clearAllSelections"
                , clearAllSelections_function_type( &::CEGUI::Listbox::clearAllSelections )
                , "*!\n\
               \n\
                  Clear the selected state for all items.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::ensureItemIsVisible
        
            typedef void ( ::CEGUI::Listbox::*ensureItemIsVisible_function_type )( ::size_t ) ;
            
            Listbox_exposer.def( 
                "ensureItemIsVisible"
                , ensureItemIsVisible_function_type( &::CEGUI::Listbox::ensureItemIsVisible )
                , ( bp::arg("item_index") )
                , "*!\n\
               \n\
                  Ensure the item at the specified index is visible within the list box.\n\
            \n\
               @param item_index\n\
                  Zero based index of the item to be made visible in the list box.  If this value is out of\
                  range, the\n\
                  list is always scrolled to the bottom.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::ensureItemIsVisible
        
            typedef void ( ::CEGUI::Listbox::*ensureItemIsVisible_function_type )( ::CEGUI::ListboxItem const * ) ;
            
            Listbox_exposer.def( 
                "ensureItemIsVisible"
                , ensureItemIsVisible_function_type( &::CEGUI::Listbox::ensureItemIsVisible )
                , ( bp::arg("item") )
                , "*!\n\
               \n\
                  Ensure the item at the specified index is visible within the list box.\n\
            \n\
               @param item\n\
                  Pointer to the ListboxItem to be made visible in the list box.\n\
            \n\
               @return\n\
                  Nothing.\n\
            \n\
               @exception  InvalidRequestException thrown if  item is not attached to this list box.\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::findItemWithText
        
            typedef ::CEGUI::ListboxItem * ( ::CEGUI::Listbox::*findItemWithText_function_type )( ::CEGUI::String const &,::CEGUI::ListboxItem const * ) ;
            
            Listbox_exposer.def( 
                "findItemWithText"
                , findItemWithText_function_type( &::CEGUI::Listbox::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\
                  ListboxItem 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 ListboxItem 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::Listbox::getFirstSelectedItem
        
            typedef ::CEGUI::ListboxItem * ( ::CEGUI::Listbox::*getFirstSelectedItem_function_type )(  ) const;
            
            Listbox_exposer.def( 
                "getFirstSelectedItem"
                , getFirstSelectedItem_function_type( &::CEGUI::Listbox::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 ListboxItem based object that is the first selected item in the list.  will\
                  return NULL if\n\
                  no item is selected.\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::getHorzScrollbar
        
            typedef ::CEGUI::Scrollbar * ( ::CEGUI::Listbox::*getHorzScrollbar_function_type )(  ) const;
            
            Listbox_exposer.def( 
                "getHorzScrollbar"
                , getHorzScrollbar_function_type( &::CEGUI::Listbox::getHorzScrollbar )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
                \n\
                    Return a pointer to the horizontal scrollbar component widget for this\n\
                    Listbox.\n\
            \n\
                @return\n\
                    Pointer to a Scrollbar object.\n\
            \n\
                @exception UnknownObjectException\n\
                    Thrown if the horizontal Scrollbar component does not exist.\n\
                *\n" );
        
        }
        { //::CEGUI::Listbox::getItemAtPoint
        
            typedef ::CEGUI::ListboxItem * ( ::CEGUI::Listbox::*getItemAtPoint_function_type )( ::CEGUI::Point const & ) const;
            
            Listbox_exposer.def( 
                "getItemAtPoint"
                , getItemAtPoint_function_type( &::CEGUI::Listbox::getItemAtPoint )
                , ( bp::arg("pt") )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
               \n\
                  Return a pointer to the ListboxItem attached to this Listbox at the\n\
                    given screen pixel co-ordinate.\n\
            \n\
               @return\n\
                  Pointer to the ListboxItem attached to this Listbox that is at screen\n\
                    position  pt, or 0 if no ListboxItem attached to this Listbox is at\n\
                    that position.\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::getItemCount
        
            typedef ::size_t ( ::CEGUI::Listbox::*getItemCount_function_type )(  ) const;
            
            Listbox_exposer.def( 
                "getItemCount"
                , getItemCount_function_type( &::CEGUI::Listbox::getItemCount )
                , "*************************************************************************\n\
                  Accessor Methods\n\
               *************************************************************************\n\
               *!\n\
               \n\
                  Return number of items attached to the list box\n\
            \n\
               @return\n\
                  the number of items currently attached to this list box.\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::getItemIndex
        
            typedef ::size_t ( ::CEGUI::Listbox::*getItemIndex_function_type )( ::CEGUI::ListboxItem const * ) const;
            
            Listbox_exposer.def( 
                "getItemIndex"
                , getItemIndex_function_type( &::CEGUI::Listbox::getItemIndex )
                , ( bp::arg("item") )
                , "*!\n\
               \n\
                  Return the index of ListboxItem  item\n\
            \n\
               @param item\n\
                  Pointer to a ListboxItem whos zero based index is to be returned.\n\
            \n\
               @return\n\
                  Zero based index indicating the position of ListboxItem  item in the list box.\n\
            \n\
               @exception  InvalidRequestException thrown if  item is not attached to this list box.\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::getListRenderArea
        
            typedef ::CEGUI::Rect ( ::CEGUI::Listbox::*getListRenderArea_function_type )(  ) const;
            typedef ::CEGUI::Rect ( Listbox_wrapper::*default_getListRenderArea_function_type )(  ) const;
            
            Listbox_exposer.def( 
                "getListRenderArea"
                , getListRenderArea_function_type(&::CEGUI::Listbox::getListRenderArea)
                , default_getListRenderArea_function_type(&Listbox_wrapper::default_getListRenderArea) );
        
        }
        { //::CEGUI::Listbox::getListboxItemFromIndex
        
            typedef ::CEGUI::ListboxItem * ( ::CEGUI::Listbox::*getListboxItemFromIndex_function_type )( ::size_t ) const;
            
            Listbox_exposer.def( 
                "getListboxItemFromIndex"
                , getListboxItemFromIndex_function_type( &::CEGUI::Listbox::getListboxItemFromIndex )
                , ( 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 ListboxItem at index position  index in the list box.\n\
            \n\
               @exception  InvalidRequestException thrown if  index is out of range.\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::getNextSelected
        
            typedef ::CEGUI::ListboxItem * ( ::CEGUI::Listbox::*getNextSelected_function_type )( ::CEGUI::ListboxItem const * ) const;
            
            Listbox_exposer.def( 
                "getNextSelected"
                , getNextSelected_function_type( &::CEGUI::Listbox::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 ListboxItem where the search for the next selected item is to begin.  If this\n\
                  parameter is NULL, the search will begin with the first item in the list box.\n\
            \n\
               @return\n\
                  Pointer to a ListboxItem based object that is the next selected item in the list after\n\
                  the item specified by  start_item.  Will return NULL if no further items were selected.\n\
            \n\
               @exception  InvalidRequestException thrown if  start_item is not attached to this list box.\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::getSelectedCount
        
            typedef ::size_t ( ::CEGUI::Listbox::*getSelectedCount_function_type )(  ) const;
            
            Listbox_exposer.def( 
                "getSelectedCount"
                , getSelectedCount_function_type( &::CEGUI::Listbox::getSelectedCount )
                , "*!\n\
               \n\
                  Return the number of selected items in the list box.\n\
            \n\
               @return\n\
                  Total number of attached items that are in the selected state.\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::getTotalItemsHeight
        
            typedef float ( ::CEGUI::Listbox::*getTotalItemsHeight_function_type )(  ) const;
            
            Listbox_exposer.def( 
                "getTotalItemsHeight"
                , getTotalItemsHeight_function_type( &::CEGUI::Listbox::getTotalItemsHeight )
                , "*!\n\
            \n\
                Return the sum of all item heights\n\
            *\n" );
        
        }
        { //::CEGUI::Listbox::getVertScrollbar
        
            typedef ::CEGUI::Scrollbar * ( ::CEGUI::Listbox::*getVertScrollbar_function_type )(  ) const;
            
            Listbox_exposer.def( 
                "getVertScrollbar"
                , getVertScrollbar_function_type( &::CEGUI::Listbox::getVertScrollbar )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
                \n\
                    Return a pointer to the vertical scrollbar component widget for this\n\
                    Listbox.\n\
            \n\
                @return\n\
                    Pointer to a Scrollbar object.\n\
            \n\
                @exception UnknownObjectException\n\
                    Thrown if the vertical Scrollbar component does not exist.\n\
                *\n" );
        
        }
        { //::CEGUI::Listbox::getWidestItemWidth
        
            typedef float ( ::CEGUI::Listbox::*getWidestItemWidth_function_type )(  ) const;
            
            Listbox_exposer.def( 
                "getWidestItemWidth"
                , getWidestItemWidth_function_type( &::CEGUI::Listbox::getWidestItemWidth )
                , "*!\n\
            \n\
                Return the width of the widest item\n\
            *\n" );
        
        }
        { //::CEGUI::Listbox::handleUpdatedItemData
        
            typedef void ( ::CEGUI::Listbox::*handleUpdatedItemData_function_type )(  ) ;
            
            Listbox_exposer.def( 
                "handleUpdatedItemData"
                , handleUpdatedItemData_function_type( &::CEGUI::Listbox::handleUpdatedItemData )
                , "*!\n\
               \n\
                  Causes the list box to update it's internal state after changes have been made to one or\
                  more\n\
                  attached ListboxItem objects.\n\
            \n\
                  Client code must call this whenever it has made any changes to ListboxItem objects already\
                  attached to the\n\
                  list box.  If you are just adding items, or removed items to update them prior to re-adding\
                  them, there is\n\
                  no need to call this method.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::initialiseComponents
        
            typedef void ( ::CEGUI::Listbox::*initialiseComponents_function_type )(  ) ;
            typedef void ( Listbox_wrapper::*default_initialiseComponents_function_type )(  ) ;
            
            Listbox_exposer.def( 
                "initialiseComponents"
                , initialiseComponents_function_type(&::CEGUI::Listbox::initialiseComponents)
                , default_initialiseComponents_function_type(&Listbox_wrapper::default_initialiseComponents) );
        
        }
        { //::CEGUI::Listbox::insertItem
        
            typedef void ( ::CEGUI::Listbox::*insertItem_function_type )( ::CEGUI::ListboxItem *,::CEGUI::ListboxItem const * ) ;
            
            Listbox_exposer.def( 
                "insertItem"
                , insertItem_function_type( &::CEGUI::Listbox::insertItem )
                , ( bp::arg("item"), bp::arg("position") )
                , "*!\n\
               \n\
                  Insert an item into the list box before a specified item already in the\n\
                    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 ListboxItem 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 ListboxItem 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\
               @exception InvalidRequestException  thrown if no ListboxItem  position is\n\
                    attached to this list box.\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::isHorzScrollbarAlwaysShown
        
            typedef bool ( ::CEGUI::Listbox::*isHorzScrollbarAlwaysShown_function_type )(  ) const;
            
            Listbox_exposer.def( 
                "isHorzScrollbarAlwaysShown"
                , isHorzScrollbarAlwaysShown_function_type( &::CEGUI::Listbox::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::Listbox::isItemSelected
        
            typedef bool ( ::CEGUI::Listbox::*isItemSelected_function_type )( ::size_t ) const;
            
            Listbox_exposer.def( 
                "isItemSelected"
                , isItemSelected_function_type( &::CEGUI::Listbox::isItemSelected )
                , ( bp::arg("index") )
                , "*!\n\
               \n\
                  return whether the string at index position  index is selected\n\
            \n\
               @param index\n\
                  Zero based index of the item to be examined.\n\
            \n\
               @return\n\
                  true if the item at  index is selected, false if the item at  index is not selected.\n\
            \n\
               @exception  InvalidRequestException thrown if  index is out of range.\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::isItemTooltipsEnabled
        
            typedef bool ( ::CEGUI::Listbox::*isItemTooltipsEnabled_function_type )(  ) const;
            
            Listbox_exposer.def( 
                "isItemTooltipsEnabled"
                , isItemTooltipsEnabled_function_type( &::CEGUI::Listbox::isItemTooltipsEnabled ) );
        
        }
        { //::CEGUI::Listbox::isListboxItemInList
        
            typedef bool ( ::CEGUI::Listbox::*isListboxItemInList_function_type )( ::CEGUI::ListboxItem const * ) const;
            
            Listbox_exposer.def( 
                "isListboxItemInList"
                , isListboxItemInList_function_type( &::CEGUI::Listbox::isListboxItemInList )
                , ( bp::arg("item") )
                , "*!\n\
               \n\
                  Return whether the specified ListboxItem is in the List\n\
            \n\
               @return\n\
                  true if ListboxItem  item is in the list, false if ListboxItem  item is not in the list.\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::isMultiselectEnabled
        
            typedef bool ( ::CEGUI::Listbox::*isMultiselectEnabled_function_type )(  ) const;
            
            Listbox_exposer.def( 
                "isMultiselectEnabled"
                , isMultiselectEnabled_function_type( &::CEGUI::Listbox::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::Listbox::isSortEnabled
        
            typedef bool ( ::CEGUI::Listbox::*isSortEnabled_function_type )(  ) const;
            
            Listbox_exposer.def( 
                "isSortEnabled"
                , isSortEnabled_function_type( &::CEGUI::Listbox::isSortEnabled )
                , "*!\n\
               \n\
                  return whether list sorting is enabled\n\
            \n\
               @return\n\
                  true if the list is sorted, false if the list is not sorted\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::isVertScrollbarAlwaysShown
        
            typedef bool ( ::CEGUI::Listbox::*isVertScrollbarAlwaysShown_function_type )(  ) const;
            
            Listbox_exposer.def( 
                "isVertScrollbarAlwaysShown"
                , isVertScrollbarAlwaysShown_function_type( &::CEGUI::Listbox::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::Listbox::removeItem
        
            typedef void ( ::CEGUI::Listbox::*removeItem_function_type )( ::CEGUI::ListboxItem const * ) ;
            
            Listbox_exposer.def( 
                "removeItem"
                , removeItem_function_type( &::CEGUI::Listbox::removeItem )
                , ( bp::arg("item") )
                , "*!\n\
               \n\
                  Removes the given item from the list box.  If the item is has the auto delete state set, the\
                  item will be deleted.\n\
            \n\
               @param item\n\
                  Pointer to the ListboxItem that is to be removed.  If  item is not attached to this list box\
                  then nothing\n\
                  will happen.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::resetList
        
            typedef void ( ::CEGUI::Listbox::*resetList_function_type )(  ) ;
            
            Listbox_exposer.def( 
                "resetList"
                , resetList_function_type( &::CEGUI::Listbox::resetList )
                , "*!\n\
               \n\
                  Remove all items from the list.\n\
            \n\
                  Note that this will cause 'AutoDelete' items to be deleted.\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::setItemSelectState
        
            typedef void ( ::CEGUI::Listbox::*setItemSelectState_function_type )( ::CEGUI::ListboxItem *,bool ) ;
            
            Listbox_exposer.def( 
                "setItemSelectState"
                , setItemSelectState_function_type( &::CEGUI::Listbox::setItemSelectState )
                , ( bp::arg("item"), bp::arg("state") )
                , "*!\n\
               \n\
                  Set the select state of an attached ListboxItem.\n\
            \n\
                  This is the recommended way of selecting and deselecting items attached to a list box as it\
                  respects the\n\
                  multi-select mode setting.  It is possible to modify the setting on ListboxItems directly, but\
                  that approach\n\
                  does not respect the settings of the list box.\n\
            \n\
               @param item\n\
                  The ListboxItem to be affected.  This item must be attached to the list box.\n\
            \n\
               @param state\n\
                  true to select the item, false to de-select the item.\n\
            \n\
               @return\n\
                  Nothing.\n\
            \n\
               @exception  InvalidRequestException thrown if  item is not attached to this list box.\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::setItemSelectState
        
            typedef void ( ::CEGUI::Listbox::*setItemSelectState_function_type )( ::size_t,bool ) ;
            
            Listbox_exposer.def( 
                "setItemSelectState"
                , setItemSelectState_function_type( &::CEGUI::Listbox::setItemSelectState )
                , ( bp::arg("item_index"), bp::arg("state") )
                , "*!\n\
               \n\
                  Set the select state of an attached ListboxItem.\n\
            \n\
                  This is the recommended way of selecting and deselecting items attached to a list box as it\
                  respects the\n\
                  multi-select mode setting.  It is possible to modify the setting on ListboxItems directly, but\
                  that approach\n\
                  does not respect the settings of the list box.\n\
            \n\
               @param item_index\n\
                  The zero based index of the ListboxItem to be affected.  This must be a valid index (0 <=\
                  index < getItemCount())\n\
            \n\
               @param state\n\
                  true to select the item, false to de-select the item.\n\
            \n\
               @return\n\
                  Nothing.\n\
            \n\
               @exception  InvalidRequestException thrown if  item_index is out of range for the list box\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::setItemTooltipsEnabled
        
            typedef void ( ::CEGUI::Listbox::*setItemTooltipsEnabled_function_type )( bool ) ;
            
            Listbox_exposer.def( 
                "setItemTooltipsEnabled"
                , setItemTooltipsEnabled_function_type( &::CEGUI::Listbox::setItemTooltipsEnabled )
                , ( bp::arg("setting") ) );
        
        }
        { //::CEGUI::Listbox::setMultiselectEnabled
        
            typedef void ( ::CEGUI::Listbox::*setMultiselectEnabled_function_type )( bool ) ;
            
            Listbox_exposer.def( 
                "setMultiselectEnabled"
                , setMultiselectEnabled_function_type( &::CEGUI::Listbox::setMultiselectEnabled )
                , ( bp::arg("setting") )
                , "*!\n\
               \n\
                  Set whether the list should allow multiple selections or just a single selection\n\
            \n\
               @param  setting\n\
                  true if the widget should allow multiple items to be selected, false if the widget should only\
                  allow\n\
                  a single selection.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::setShowHorzScrollbar
        
            typedef void ( ::CEGUI::Listbox::*setShowHorzScrollbar_function_type )( bool ) ;
            
            Listbox_exposer.def( 
                "setShowHorzScrollbar"
                , setShowHorzScrollbar_function_type( &::CEGUI::Listbox::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 required.  false if the\
                  horizontal\n\
                  scroll bar should only be shown when it is required.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::setShowVertScrollbar
        
            typedef void ( ::CEGUI::Listbox::*setShowVertScrollbar_function_type )( bool ) ;
            
            Listbox_exposer.def( 
                "setShowVertScrollbar"
                , setShowVertScrollbar_function_type( &::CEGUI::Listbox::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 required.  false if the\
                  vertical\n\
                  scroll bar should only be shown when it is required.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Listbox::setSortingEnabled
        
            typedef void ( ::CEGUI::Listbox::*setSortingEnabled_function_type )( bool ) ;
            
            Listbox_exposer.def( 
                "setSortingEnabled"
                , setSortingEnabled_function_type( &::CEGUI::Listbox::setSortingEnabled )
                , ( bp::arg("setting") )
                , "*!\n\
               \n\
                  Set whether the list should be sorted.\n\
            \n\
               @param setting\n\
                  true if the list should be sorted, false if the list should not be sorted.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        Listbox_exposer.add_static_property( "EventHorzScrollbarModeChanged"
                        , bp::make_getter( &CEGUI::Listbox::EventHorzScrollbarModeChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Listbox_exposer.add_static_property( "EventListContentsChanged"
                        , bp::make_getter( &CEGUI::Listbox::EventListContentsChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Listbox_exposer.add_static_property( "EventMultiselectModeChanged"
                        , bp::make_getter( &CEGUI::Listbox::EventMultiselectModeChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Listbox_exposer.add_static_property( "EventSelectionChanged"
                        , bp::make_getter( &CEGUI::Listbox::EventSelectionChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Listbox_exposer.add_static_property( "EventSortModeChanged"
                        , bp::make_getter( &CEGUI::Listbox::EventSortModeChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Listbox_exposer.add_static_property( "EventVertScrollbarModeChanged"
                        , bp::make_getter( &CEGUI::Listbox::EventVertScrollbarModeChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Listbox_exposer.add_static_property( "HorzScrollbarNameSuffix"
                        , bp::make_getter( &CEGUI::Listbox::HorzScrollbarNameSuffix
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Listbox_exposer.add_static_property( "VertScrollbarNameSuffix"
                        , bp::make_getter( &CEGUI::Listbox::VertScrollbarNameSuffix
                                , bp::return_value_policy< bp::return_by_value >() ) );
        { //::CEGUI::Window::beginInitialisation
        
            typedef void ( ::CEGUI::Window::*beginInitialisation_function_type )(  ) ;
            typedef void ( Listbox_wrapper::*default_beginInitialisation_function_type )(  ) ;
            
            Listbox_exposer.def( 
                "beginInitialisation"
                , beginInitialisation_function_type(&::CEGUI::Window::beginInitialisation)
                , default_beginInitialisation_function_type(&Listbox_wrapper::default_beginInitialisation) );
        
        }
        { //::CEGUI::Window::cloneChildWidgetsTo
        
            typedef void ( ::CEGUI::Window::*cloneChildWidgetsTo_function_type )( ::CEGUI::Window & ) const;
            typedef void ( Listbox_wrapper::*default_cloneChildWidgetsTo_function_type )( ::CEGUI::Window & ) const;
            
            Listbox_exposer.def( 
                "cloneChildWidgetsTo"
                , cloneChildWidgetsTo_function_type(&::CEGUI::Window::cloneChildWidgetsTo)
                , default_cloneChildWidgetsTo_function_type(&Listbox_wrapper::default_cloneChildWidgetsTo)
                , ( bp::arg("target") ) );
        
        }
        { //::CEGUI::Window::clonePropertiesTo
        
            typedef void ( ::CEGUI::Window::*clonePropertiesTo_function_type )( ::CEGUI::Window & ) const;
            typedef void ( Listbox_wrapper::*default_clonePropertiesTo_function_type )( ::CEGUI::Window & ) const;
            
            Listbox_exposer.def( 
                "clonePropertiesTo"
                , clonePropertiesTo_function_type(&::CEGUI::Window::clonePropertiesTo)
                , default_clonePropertiesTo_function_type(&Listbox_wrapper::default_clonePropertiesTo)
                , ( bp::arg("target") ) );
        
        }
        { //::CEGUI::Window::destroy
        
            typedef void ( ::CEGUI::Window::*destroy_function_type )(  ) ;
            typedef void ( Listbox_wrapper::*default_destroy_function_type )(  ) ;
            
            Listbox_exposer.def( 
                "destroy"
                , destroy_function_type(&::CEGUI::Window::destroy)
                , default_destroy_function_type(&Listbox_wrapper::default_destroy) );
        
        }
        { //::CEGUI::Window::endInitialisation
        
            typedef void ( ::CEGUI::Window::*endInitialisation_function_type )(  ) ;
            typedef void ( Listbox_wrapper::*default_endInitialisation_function_type )(  ) ;
            
            Listbox_exposer.def( 
                "endInitialisation"
                , endInitialisation_function_type(&::CEGUI::Window::endInitialisation)
                , default_endInitialisation_function_type(&Listbox_wrapper::default_endInitialisation) );
        
        }
        { //::CEGUI::EventSet::fireEvent
        
            typedef void ( ::CEGUI::EventSet::*fireEvent_function_type )( ::CEGUI::String const &,::CEGUI::EventArgs &,::CEGUI::String const & ) ;
            typedef void ( Listbox_wrapper::*default_fireEvent_function_type )( ::CEGUI::String const &,::CEGUI::EventArgs &,::CEGUI::String const & ) ;
            
            Listbox_exposer.def( 
                "fireEvent"
                , fireEvent_function_type(&::CEGUI::EventSet::fireEvent)
                , default_fireEvent_function_type(&Listbox_wrapper::default_fireEvent)
                , ( bp::arg("name"), bp::arg("args"), bp::arg("eventNamespace")="" ) );
        
        }
        { //::CEGUI::Window::getRenderedStringParser
        
            typedef ::CEGUI::RenderedStringParser & ( ::CEGUI::Window::*getRenderedStringParser_function_type )(  ) const;
            
            Listbox_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 ( Listbox_wrapper::*default_getRenderingContext_impl_function_type )( ::CEGUI::RenderingContext & ) const;
            
            Listbox_exposer.def( 
                "getRenderingContext_impl"
                , getRenderingContext_impl_function_type(&::CEGUI::Window::getRenderingContext_impl)
                , default_getRenderingContext_impl_function_type(&Listbox_wrapper::default_getRenderingContext_impl)
                , ( bp::arg("ctx") ) );
        
        }
        { //::CEGUI::Window::getUnclippedInnerRect_impl
        
            typedef ::CEGUI::Rect ( ::CEGUI::Window::*getUnclippedInnerRect_impl_function_type )(  ) const;
            typedef ::CEGUI::Rect ( Listbox_wrapper::*default_getUnclippedInnerRect_impl_function_type )(  ) const;
            
            Listbox_exposer.def( 
                "getUnclippedInnerRect_impl"
                , getUnclippedInnerRect_impl_function_type(&::CEGUI::Window::getUnclippedInnerRect_impl)
                , default_getUnclippedInnerRect_impl_function_type(&Listbox_wrapper::default_getUnclippedInnerRect_impl) );
        
        }
        { //::CEGUI::Window::isHit
        
            typedef bool ( ::CEGUI::Window::*isHit_function_type )( ::CEGUI::Vector2 const &,bool const ) const;
            typedef bool ( Listbox_wrapper::*default_isHit_function_type )( ::CEGUI::Vector2 const &,bool const ) const;
            
            Listbox_exposer.def( 
                "isHit"
                , isHit_function_type(&::CEGUI::Window::isHit)
                , default_isHit_function_type(&Listbox_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 ( Listbox_wrapper::*default_performChildWindowLayout_function_type )(  ) ;
            
            Listbox_exposer.def( 
                "performChildWindowLayout"
                , performChildWindowLayout_function_type(&::CEGUI::Window::performChildWindowLayout)
                , default_performChildWindowLayout_function_type(&Listbox_wrapper::default_performChildWindowLayout) );
        
        }
        { //::CEGUI::Window::setLookNFeel
        
            typedef void ( ::CEGUI::Window::*setLookNFeel_function_type )( ::CEGUI::String const & ) ;
            typedef void ( Listbox_wrapper::*default_setLookNFeel_function_type )( ::CEGUI::String const & ) ;
            
            Listbox_exposer.def( 
                "setLookNFeel"
                , setLookNFeel_function_type(&::CEGUI::Window::setLookNFeel)
                , default_setLookNFeel_function_type(&Listbox_wrapper::default_setLookNFeel)
                , ( bp::arg("look") ) );
        
        }
        { //::CEGUI::Window::setMargin
        
            typedef void ( ::CEGUI::Window::*setMargin_function_type )( ::CEGUI::UBox const & ) ;
            typedef void ( Listbox_wrapper::*default_setMargin_function_type )( ::CEGUI::UBox const & ) ;
            
            Listbox_exposer.def( 
                "setMargin"
                , setMargin_function_type(&::CEGUI::Window::setMargin)
                , default_setMargin_function_type(&Listbox_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 > ( Listbox_wrapper::*default_subscribeScriptedEvent_function_type )( ::CEGUI::String const &,::CEGUI::String const & ) ;
            
            Listbox_exposer.def( 
                "subscribeScriptedEvent"
                , subscribeScriptedEvent_function_type(&::CEGUI::EventSet::subscribeScriptedEvent)
                , default_subscribeScriptedEvent_function_type(&Listbox_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 > ( Listbox_wrapper::*default_subscribeScriptedEvent_function_type )( ::CEGUI::String const &,unsigned int,::CEGUI::String const & ) ;
            
            Listbox_exposer.def( 
                "subscribeScriptedEvent"
                , subscribeScriptedEvent_function_type(&::CEGUI::EventSet::subscribeScriptedEvent)
                , default_subscribeScriptedEvent_function_type(&Listbox_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 ( Listbox_wrapper::*default_update_function_type )( float ) ;
            
            Listbox_exposer.def( 
                "update"
                , update_function_type(&::CEGUI::Window::update)
                , default_update_function_type(&Listbox_wrapper::default_update)
                , ( bp::arg("elapsed") ) );
        
        }
        { //::CEGUI::Window::writeXMLToStream
        
            typedef void ( ::CEGUI::Window::*writeXMLToStream_function_type )( ::CEGUI::XMLSerializer & ) const;
            typedef void ( Listbox_wrapper::*default_writeXMLToStream_function_type )( ::CEGUI::XMLSerializer & ) const;
            
            Listbox_exposer.def( 
                "writeXMLToStream"
                , writeXMLToStream_function_type(&::CEGUI::Window::writeXMLToStream)
                , default_writeXMLToStream_function_type(&Listbox_wrapper::default_writeXMLToStream)
                , ( bp::arg("xml_stream") ) );
        
        }
    }

}
