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

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

namespace bp = boost::python;

struct Scrollbar_wrapper : CEGUI::Scrollbar, bp::wrapper< CEGUI::Scrollbar > {

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

    virtual void initialiseComponents(  ) {
        if( bp::override func_initialiseComponents = this->get_override( "initialiseComponents" ) )
            func_initialiseComponents(  );
        else{
            this->CEGUI::Scrollbar::initialiseComponents(  );
        }
    }
    
    void default_initialiseComponents(  ) {
        CEGUI::Scrollbar::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_Scrollbar_class(){

    { //::CEGUI::Scrollbar
        typedef bp::class_< Scrollbar_wrapper, bp::bases< CEGUI::Window >, boost::noncopyable > Scrollbar_exposer_t;
        Scrollbar_exposer_t Scrollbar_exposer = Scrollbar_exposer_t( "Scrollbar", "*!\n\
        \n\
            Base scroll bar class.\n\
        \n\
            This base class for scroll bars does not have any idea of direction - a\n\
            derived class would add whatever meaning is appropriate according to what\n\
            that derived class represents to the user.\n\
        *\n", bp::init< CEGUI::String const &, CEGUI::String const & >(( bp::arg("type"), bp::arg("name") ), "! Constructor for Scrollbar objects\n") );
        bp::scope Scrollbar_scope( Scrollbar_exposer );
        { //::CEGUI::Scrollbar::getDecreaseButton
        
            typedef ::CEGUI::PushButton * ( ::CEGUI::Scrollbar::*getDecreaseButton_function_type )(  ) const;
            
            Scrollbar_exposer.def( 
                "getDecreaseButton"
                , getDecreaseButton_function_type( &::CEGUI::Scrollbar::getDecreaseButton )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
                \n\
                    Return a pointer to the 'decrease' PushButton component widget for this\n\
                    Scrollbar.\n\
            \n\
                @return\n\
                    Pointer to a PushButton object.\n\
            \n\
                @exception UnknownObjectException\n\
                    Thrown if the 'decrease' PushButton component does not exist.\n\
                *\n" );
        
        }
        { //::CEGUI::Scrollbar::getDocumentSize
        
            typedef float ( ::CEGUI::Scrollbar::*getDocumentSize_function_type )(  ) const;
            
            Scrollbar_exposer.def( 
                "getDocumentSize"
                , getDocumentSize_function_type( &::CEGUI::Scrollbar::getDocumentSize )
                , "*************************************************************************\n\
                    Accessor functions\n\
                *************************************************************************\n\
                *!\n\
                \n\
                    Return the size of the document or data.\n\
            \n\
                    The document size should be thought of as the total size of the data\n\
                    that is being scrolled through (the number of lines in a text file for\n\
                    example).\n\
            \n\
                \note\n\
                    The returned value has no meaning within the Gui system, it is left up\n\
                    to the application to assign appropriate values for the application\n\
                    specific use of the scroll bar.\n\
            \n\
                @return\n\
                    float value specifying the currently set document size.\n\
                *\n" );
        
        }
        { //::CEGUI::Scrollbar::getIncreaseButton
        
            typedef ::CEGUI::PushButton * ( ::CEGUI::Scrollbar::*getIncreaseButton_function_type )(  ) const;
            
            Scrollbar_exposer.def( 
                "getIncreaseButton"
                , getIncreaseButton_function_type( &::CEGUI::Scrollbar::getIncreaseButton )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
                \n\
                    Return a pointer to the 'increase' PushButtoncomponent widget for this\n\
                    Scrollbar.\n\
            \n\
                @return\n\
                    Pointer to a PushButton object.\n\
            \n\
                @exception UnknownObjectException\n\
                    Thrown if the increase PushButton component does not exist.\n\
                *\n" );
        
        }
        { //::CEGUI::Scrollbar::getOverlapSize
        
            typedef float ( ::CEGUI::Scrollbar::*getOverlapSize_function_type )(  ) const;
            
            Scrollbar_exposer.def( 
                "getOverlapSize"
                , getOverlapSize_function_type( &::CEGUI::Scrollbar::getOverlapSize )
                , "*!\n\
                \n\
                    Return the overlap size for this scroll bar.\n\
            \n\
                    The overlap size is the amount of data from the end of a 'page' that\n\
                    will remain visible when the position is moved by a page.  This is\n\
                    usually used so that the user keeps some context of where they were\n\
                    within the document's data when jumping a page at a time.\n\
            \n\
                \note\n\
                    The returned value has no meaning within the Gui system, it is left up\n\
                    to the application to assign appropriate values for the application\n\
                    specific use of the scroll bar.\n\
            \n\
                @return\n\
                    float value specifying the currently set overlap size.\n\
                *\n" );
        
        }
        { //::CEGUI::Scrollbar::getPageSize
        
            typedef float ( ::CEGUI::Scrollbar::*getPageSize_function_type )(  ) const;
            
            Scrollbar_exposer.def( 
                "getPageSize"
                , getPageSize_function_type( &::CEGUI::Scrollbar::getPageSize )
                , "*!\n\
                \n\
                    Return the page size for this scroll bar.\n\
            \n\
                    The page size is typically the amount of data that can be displayed at\n\
                    one time.  This value is also used when calculating the amount the\n\
                    position will change when you click either side of the scroll bar\n\
                    thumb, the amount the position changes will is (pageSize - overlapSize).\n\
            \n\
                \note\n\
                    The returned value has no meaning within the Gui system, it is left up\n\
                    to the application to assign appropriate values for the application\n\
                    specific use of the scroll bar.\n\
            \n\
                @return\n\
                    float value specifying the currently set page size.\n\
                *\n" );
        
        }
        { //::CEGUI::Scrollbar::getScrollPosition
        
            typedef float ( ::CEGUI::Scrollbar::*getScrollPosition_function_type )(  ) const;
            
            Scrollbar_exposer.def( 
                "getScrollPosition"
                , getScrollPosition_function_type( &::CEGUI::Scrollbar::getScrollPosition )
                , "*!\n\
                \n\
                    Return the current position of scroll bar within the document.\n\
            \n\
                    The range of the scroll bar is from 0 to the size of the document minus\n\
                    the size of a page (0 <= position <= (documentSize - pageSize)).\n\
            \n\
                \note\n\
                    The returned value has no meaning within the Gui system, it is left up\n\
                    to the application to assign appropriate values for the application\n\
                    specific use of the scroll bar.\n\
            \n\
                @return\n\
                    float value specifying the current position of the scroll bar within its\n\
                    document.\n\
                *\n" );
        
        }
        { //::CEGUI::Scrollbar::getStepSize
        
            typedef float ( ::CEGUI::Scrollbar::*getStepSize_function_type )(  ) const;
            
            Scrollbar_exposer.def( 
                "getStepSize"
                , getStepSize_function_type( &::CEGUI::Scrollbar::getStepSize )
                , "*!\n\
                \n\
                    Return the step size for this scroll bar.\n\
            \n\
                    The step size is typically a single unit of data that can be displayed,\n\
                    this is the amount the position will change when you click either of\n\
                    the arrow buttons on the scroll bar.  (this could be 1 for a single\n\
                    line of text, for example).\n\
            \n\
                \note\n\
                    The returned value has no meaning within the Gui system, it is left up\n\
                    to the application to assign appropriate values for the application\n\
                    specific use of the scroll bar.\n\
            \n\
                @return\n\
                    float value specifying the currently set step size.\n\
                *\n" );
        
        }
        { //::CEGUI::Scrollbar::getThumb
        
            typedef ::CEGUI::Thumb * ( ::CEGUI::Scrollbar::*getThumb_function_type )(  ) const;
            
            Scrollbar_exposer.def( 
                "getThumb"
                , getThumb_function_type( &::CEGUI::Scrollbar::getThumb )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
                \n\
                    Return a pointer to the Thumb component widget for this Scrollbar.\n\
            \n\
                @return\n\
                    Pointer to a Thumb object.\n\
            \n\
                @exception UnknownObjectException\n\
                    Thrown if the Thumb component does not exist.\n\
                *\n" );
        
        }
        { //::CEGUI::Scrollbar::initialiseComponents
        
            typedef void ( ::CEGUI::Scrollbar::*initialiseComponents_function_type )(  ) ;
            typedef void ( Scrollbar_wrapper::*default_initialiseComponents_function_type )(  ) ;
            
            Scrollbar_exposer.def( 
                "initialiseComponents"
                , initialiseComponents_function_type(&::CEGUI::Scrollbar::initialiseComponents)
                , default_initialiseComponents_function_type(&Scrollbar_wrapper::default_initialiseComponents) );
        
        }
        { //::CEGUI::Scrollbar::isEndLockEnabled
        
            typedef bool ( ::CEGUI::Scrollbar::*isEndLockEnabled_function_type )(  ) const;
            
            Scrollbar_exposer.def( 
                "isEndLockEnabled"
                , isEndLockEnabled_function_type( &::CEGUI::Scrollbar::isEndLockEnabled )
                , "*!\n\
                \n\
                    Returns whether the 'end lock'mode for the scrollbar is enabled.\n\
            \n\
                    When enabled, and the current position of the scrollbar is at the end of\n\
                    it's travel, the end lock mode of the scrollbar will automatically\n\
                    update the scrollbar position when the document andor page size change\n\
                    in order that the scroll position will remain at the end of it's travel.\n\
                    This can be used to implement auto-scrolling in certain other widget\n\
                    types.\n\
            \n\
                @return\n\
                    - true to indicate that the end lock mode is enabled.\n\
                    - false to indicate that the end lock mode is disabled.\n\
                *\n" );
        
        }
        { //::CEGUI::Scrollbar::setConfig
        
            typedef void ( ::CEGUI::Scrollbar::*setConfig_function_type )( float const * const,float const * const,float const * const,float const * const,float const * const ) ;
            
            Scrollbar_exposer.def( 
                "setConfig"
                , setConfig_function_type( &::CEGUI::Scrollbar::setConfig )
                , ( bp::arg("document_size"), bp::arg("page_size"), bp::arg("step_size"), bp::arg("overlap_size"), bp::arg("position") ) );
        
        }
        { //::CEGUI::Scrollbar::setDocumentSize
        
            typedef void ( ::CEGUI::Scrollbar::*setDocumentSize_function_type )( float ) ;
            
            Scrollbar_exposer.def( 
                "setDocumentSize"
                , setDocumentSize_function_type( &::CEGUI::Scrollbar::setDocumentSize )
                , ( bp::arg("document_size") )
                , "*!\n\
                \n\
                    Set the size of the document or data.\n\
            \n\
                    The document size should be thought of as the total size of the data\n\
                    that is being scrolled through (the number of lines in a text file for\n\
                    example).\n\
            \n\
                \note\n\
                    The value set has no meaning within the Gui system, it is left up to\n\
                    the application to assign appropriate values for the application\n\
                    specific use of the scroll bar.\n\
            \n\
                @param document_size\n\
                    float value specifying the document size.\n\
            \n\
                @return\n\
                    Nothing.\n\
                *\n" );
        
        }
        { //::CEGUI::Scrollbar::setEndLockEnabled
        
            typedef void ( ::CEGUI::Scrollbar::*setEndLockEnabled_function_type )( bool const ) ;
            
            Scrollbar_exposer.def( 
                "setEndLockEnabled"
                , setEndLockEnabled_function_type( &::CEGUI::Scrollbar::setEndLockEnabled )
                , ( bp::arg("enabled") )
                , "*!\n\
                \n\
                    Enable or disable the 'end lock' mode for the scrollbar.\n\
            \n\
                    When enabled and the current position of the scrollbar is at the end of\n\
                    it's travel, the end lock mode of the scrollbar will automatically\n\
                    update the position when the document andor page size change in order\n\
                    that the scroll position will remain at the end of it's travel.  This\n\
                    can be used to implement auto-scrolling in certain other widget types.\n\
            \n\
                @param enabled\n\
                    - true to indicate that end lock mode should be enabled.\n\
                    - false to indicate that end lock mode should be disabled.\n\
                *\n" );
        
        }
        { //::CEGUI::Scrollbar::setOverlapSize
        
            typedef void ( ::CEGUI::Scrollbar::*setOverlapSize_function_type )( float ) ;
            
            Scrollbar_exposer.def( 
                "setOverlapSize"
                , setOverlapSize_function_type( &::CEGUI::Scrollbar::setOverlapSize )
                , ( bp::arg("overlap_size") )
                , "*!\n\
                \n\
                    Set the overlap size for this scroll bar.\n\
            \n\
                    The overlap size is the amount of data from the end of a 'page' that\n\
                    will remain visible when the position is moved by a page.  This is\n\
                    usually used so that the user keeps some context of where they were\n\
                    within the document's data when jumping a page at a time.\n\
            \n\
                \note\n\
                    The value set has no meaning within the Gui system, it is left up to the\n\
                    application to assign appropriate values for the application specific\n\
                    use of the scroll bar.\n\
            \n\
                @param overlap_size\n\
                    float value specifying the overlap size.\n\
            \n\
                @return\n\
                    Nothing.\n\
                *\n" );
        
        }
        { //::CEGUI::Scrollbar::setPageSize
        
            typedef void ( ::CEGUI::Scrollbar::*setPageSize_function_type )( float ) ;
            
            Scrollbar_exposer.def( 
                "setPageSize"
                , setPageSize_function_type( &::CEGUI::Scrollbar::setPageSize )
                , ( bp::arg("page_size") )
                , "*!\n\
                \n\
                    Set the page size for this scroll bar.\n\
            \n\
                    The page size is typically the amount of data that can be displayed at\n\
                    one time.  This value is also used when calculating the amount the\n\
                    position will change when you click either side of the scroll bar\n\
                    thumb, the amount the position changes will is (pageSize - overlapSize).\n\
            \n\
                \note\n\
                    The value set has no meaning within the Gui system, it is left up to the\n\
                    application to assign appropriate values for the application specific\n\
                    use of the scroll bar.\n\
            \n\
                @param page_size\n\
                    float value specifying the page size.\n\
            \n\
                @return\n\
                    Nothing.\n\
                *\n" );
        
        }
        { //::CEGUI::Scrollbar::setScrollPosition
        
            typedef void ( ::CEGUI::Scrollbar::*setScrollPosition_function_type )( float ) ;
            
            Scrollbar_exposer.def( 
                "setScrollPosition"
                , setScrollPosition_function_type( &::CEGUI::Scrollbar::setScrollPosition )
                , ( bp::arg("position") )
                , "*!\n\
                \n\
                    Set the current position of scroll bar within the document.\n\
            \n\
                    The range of the scroll bar is from 0 to the size of the document minus\n\
                    the size of a page (0 <= position <= (documentSize - pageSize)), any\n\
                    attempt to set the position outside this range will be adjusted so that\n\
                    it falls within the legal range.\n\
            \n\
                \note\n\
                    The returned value has no meaning within the Gui system, it is left up\n\
                    to the application to assign appropriate values for the application\n\
                    specific use of the scroll bar.\n\
            \n\
                @param position\n\
                    float value specifying the position of the scroll bar within its\n\
                    document.\n\
            \n\
                @return\n\
                    Nothing.\n\
                *\n" );
        
        }
        { //::CEGUI::Scrollbar::setStepSize
        
            typedef void ( ::CEGUI::Scrollbar::*setStepSize_function_type )( float ) ;
            
            Scrollbar_exposer.def( 
                "setStepSize"
                , setStepSize_function_type( &::CEGUI::Scrollbar::setStepSize )
                , ( bp::arg("step_size") )
                , "*!\n\
                \n\
                    Set the step size for this scroll bar.\n\
            \n\
                    The step size is typically a single unit of data that can be displayed,\n\
                    this is the amount the position will change when you click either of the\n\
                    arrow buttons on the scroll bar.  (this could be 1 for a single line of\n\
                    text, for example).\n\
            \n\
                \note\n\
                    The value set has no meaning within the Gui system, it is left up to the\n\
                    application to assign appropriate values for the application specific\n\
                    use of the scroll bar.\n\
            \n\
                @param step_size\n\
                    float value specifying the step size.\n\
            \n\
                @return\n\
                    Nothing.\n\
                *\n" );
        
        }
        Scrollbar_exposer.add_static_property( "DecreaseButtonNameSuffix"
                        , bp::make_getter( &CEGUI::Scrollbar::DecreaseButtonNameSuffix
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Scrollbar_exposer.add_static_property( "EventScrollConfigChanged"
                        , bp::make_getter( &CEGUI::Scrollbar::EventScrollConfigChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Scrollbar_exposer.add_static_property( "EventScrollPositionChanged"
                        , bp::make_getter( &CEGUI::Scrollbar::EventScrollPositionChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Scrollbar_exposer.add_static_property( "EventThumbTrackEnded"
                        , bp::make_getter( &CEGUI::Scrollbar::EventThumbTrackEnded
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Scrollbar_exposer.add_static_property( "EventThumbTrackStarted"
                        , bp::make_getter( &CEGUI::Scrollbar::EventThumbTrackStarted
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Scrollbar_exposer.add_static_property( "IncreaseButtonNameSuffix"
                        , bp::make_getter( &CEGUI::Scrollbar::IncreaseButtonNameSuffix
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Scrollbar_exposer.add_static_property( "ThumbNameSuffix"
                        , bp::make_getter( &CEGUI::Scrollbar::ThumbNameSuffix
                                , bp::return_value_policy< bp::return_by_value >() ) );
        { //::CEGUI::Window::beginInitialisation
        
            typedef void ( ::CEGUI::Window::*beginInitialisation_function_type )(  ) ;
            typedef void ( Scrollbar_wrapper::*default_beginInitialisation_function_type )(  ) ;
            
            Scrollbar_exposer.def( 
                "beginInitialisation"
                , beginInitialisation_function_type(&::CEGUI::Window::beginInitialisation)
                , default_beginInitialisation_function_type(&Scrollbar_wrapper::default_beginInitialisation) );
        
        }
        { //::CEGUI::Window::cloneChildWidgetsTo
        
            typedef void ( ::CEGUI::Window::*cloneChildWidgetsTo_function_type )( ::CEGUI::Window & ) const;
            typedef void ( Scrollbar_wrapper::*default_cloneChildWidgetsTo_function_type )( ::CEGUI::Window & ) const;
            
            Scrollbar_exposer.def( 
                "cloneChildWidgetsTo"
                , cloneChildWidgetsTo_function_type(&::CEGUI::Window::cloneChildWidgetsTo)
                , default_cloneChildWidgetsTo_function_type(&Scrollbar_wrapper::default_cloneChildWidgetsTo)
                , ( bp::arg("target") ) );
        
        }
        { //::CEGUI::Window::clonePropertiesTo
        
            typedef void ( ::CEGUI::Window::*clonePropertiesTo_function_type )( ::CEGUI::Window & ) const;
            typedef void ( Scrollbar_wrapper::*default_clonePropertiesTo_function_type )( ::CEGUI::Window & ) const;
            
            Scrollbar_exposer.def( 
                "clonePropertiesTo"
                , clonePropertiesTo_function_type(&::CEGUI::Window::clonePropertiesTo)
                , default_clonePropertiesTo_function_type(&Scrollbar_wrapper::default_clonePropertiesTo)
                , ( bp::arg("target") ) );
        
        }
        { //::CEGUI::Window::destroy
        
            typedef void ( ::CEGUI::Window::*destroy_function_type )(  ) ;
            typedef void ( Scrollbar_wrapper::*default_destroy_function_type )(  ) ;
            
            Scrollbar_exposer.def( 
                "destroy"
                , destroy_function_type(&::CEGUI::Window::destroy)
                , default_destroy_function_type(&Scrollbar_wrapper::default_destroy) );
        
        }
        { //::CEGUI::Window::endInitialisation
        
            typedef void ( ::CEGUI::Window::*endInitialisation_function_type )(  ) ;
            typedef void ( Scrollbar_wrapper::*default_endInitialisation_function_type )(  ) ;
            
            Scrollbar_exposer.def( 
                "endInitialisation"
                , endInitialisation_function_type(&::CEGUI::Window::endInitialisation)
                , default_endInitialisation_function_type(&Scrollbar_wrapper::default_endInitialisation) );
        
        }
        { //::CEGUI::EventSet::fireEvent
        
            typedef void ( ::CEGUI::EventSet::*fireEvent_function_type )( ::CEGUI::String const &,::CEGUI::EventArgs &,::CEGUI::String const & ) ;
            typedef void ( Scrollbar_wrapper::*default_fireEvent_function_type )( ::CEGUI::String const &,::CEGUI::EventArgs &,::CEGUI::String const & ) ;
            
            Scrollbar_exposer.def( 
                "fireEvent"
                , fireEvent_function_type(&::CEGUI::EventSet::fireEvent)
                , default_fireEvent_function_type(&Scrollbar_wrapper::default_fireEvent)
                , ( bp::arg("name"), bp::arg("args"), bp::arg("eventNamespace")="" ) );
        
        }
        { //::CEGUI::Window::getRenderedStringParser
        
            typedef ::CEGUI::RenderedStringParser & ( ::CEGUI::Window::*getRenderedStringParser_function_type )(  ) const;
            
            Scrollbar_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 ( Scrollbar_wrapper::*default_getRenderingContext_impl_function_type )( ::CEGUI::RenderingContext & ) const;
            
            Scrollbar_exposer.def( 
                "getRenderingContext_impl"
                , getRenderingContext_impl_function_type(&::CEGUI::Window::getRenderingContext_impl)
                , default_getRenderingContext_impl_function_type(&Scrollbar_wrapper::default_getRenderingContext_impl)
                , ( bp::arg("ctx") ) );
        
        }
        { //::CEGUI::Window::getUnclippedInnerRect_impl
        
            typedef ::CEGUI::Rect ( ::CEGUI::Window::*getUnclippedInnerRect_impl_function_type )(  ) const;
            typedef ::CEGUI::Rect ( Scrollbar_wrapper::*default_getUnclippedInnerRect_impl_function_type )(  ) const;
            
            Scrollbar_exposer.def( 
                "getUnclippedInnerRect_impl"
                , getUnclippedInnerRect_impl_function_type(&::CEGUI::Window::getUnclippedInnerRect_impl)
                , default_getUnclippedInnerRect_impl_function_type(&Scrollbar_wrapper::default_getUnclippedInnerRect_impl) );
        
        }
        { //::CEGUI::Window::isHit
        
            typedef bool ( ::CEGUI::Window::*isHit_function_type )( ::CEGUI::Vector2 const &,bool const ) const;
            typedef bool ( Scrollbar_wrapper::*default_isHit_function_type )( ::CEGUI::Vector2 const &,bool const ) const;
            
            Scrollbar_exposer.def( 
                "isHit"
                , isHit_function_type(&::CEGUI::Window::isHit)
                , default_isHit_function_type(&Scrollbar_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 ( Scrollbar_wrapper::*default_performChildWindowLayout_function_type )(  ) ;
            
            Scrollbar_exposer.def( 
                "performChildWindowLayout"
                , performChildWindowLayout_function_type(&::CEGUI::Window::performChildWindowLayout)
                , default_performChildWindowLayout_function_type(&Scrollbar_wrapper::default_performChildWindowLayout) );
        
        }
        { //::CEGUI::Window::setLookNFeel
        
            typedef void ( ::CEGUI::Window::*setLookNFeel_function_type )( ::CEGUI::String const & ) ;
            typedef void ( Scrollbar_wrapper::*default_setLookNFeel_function_type )( ::CEGUI::String const & ) ;
            
            Scrollbar_exposer.def( 
                "setLookNFeel"
                , setLookNFeel_function_type(&::CEGUI::Window::setLookNFeel)
                , default_setLookNFeel_function_type(&Scrollbar_wrapper::default_setLookNFeel)
                , ( bp::arg("look") ) );
        
        }
        { //::CEGUI::Window::setMargin
        
            typedef void ( ::CEGUI::Window::*setMargin_function_type )( ::CEGUI::UBox const & ) ;
            typedef void ( Scrollbar_wrapper::*default_setMargin_function_type )( ::CEGUI::UBox const & ) ;
            
            Scrollbar_exposer.def( 
                "setMargin"
                , setMargin_function_type(&::CEGUI::Window::setMargin)
                , default_setMargin_function_type(&Scrollbar_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 > ( Scrollbar_wrapper::*default_subscribeScriptedEvent_function_type )( ::CEGUI::String const &,::CEGUI::String const & ) ;
            
            Scrollbar_exposer.def( 
                "subscribeScriptedEvent"
                , subscribeScriptedEvent_function_type(&::CEGUI::EventSet::subscribeScriptedEvent)
                , default_subscribeScriptedEvent_function_type(&Scrollbar_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 > ( Scrollbar_wrapper::*default_subscribeScriptedEvent_function_type )( ::CEGUI::String const &,unsigned int,::CEGUI::String const & ) ;
            
            Scrollbar_exposer.def( 
                "subscribeScriptedEvent"
                , subscribeScriptedEvent_function_type(&::CEGUI::EventSet::subscribeScriptedEvent)
                , default_subscribeScriptedEvent_function_type(&Scrollbar_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 ( Scrollbar_wrapper::*default_update_function_type )( float ) ;
            
            Scrollbar_exposer.def( 
                "update"
                , update_function_type(&::CEGUI::Window::update)
                , default_update_function_type(&Scrollbar_wrapper::default_update)
                , ( bp::arg("elapsed") ) );
        
        }
        { //::CEGUI::Window::writeXMLToStream
        
            typedef void ( ::CEGUI::Window::*writeXMLToStream_function_type )( ::CEGUI::XMLSerializer & ) const;
            typedef void ( Scrollbar_wrapper::*default_writeXMLToStream_function_type )( ::CEGUI::XMLSerializer & ) const;
            
            Scrollbar_exposer.def( 
                "writeXMLToStream"
                , writeXMLToStream_function_type(&::CEGUI::Window::writeXMLToStream)
                , default_writeXMLToStream_function_type(&Scrollbar_wrapper::default_writeXMLToStream)
                , ( bp::arg("xml_stream") ) );
        
        }
    }

}
