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

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

namespace bp = boost::python;

struct ScrollablePane_wrapper : CEGUI::ScrollablePane, bp::wrapper< CEGUI::ScrollablePane > {

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

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

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

    { //::CEGUI::ScrollablePane
        typedef bp::class_< ScrollablePane_wrapper, bp::bases< CEGUI::Window >, boost::noncopyable > ScrollablePane_exposer_t;
        ScrollablePane_exposer_t ScrollablePane_exposer = ScrollablePane_exposer_t( "ScrollablePane", "*!\n\
        \n\
            Base class for the ScrollablePane widget.\n\
        \n\
            The ScrollablePane widget allows child windows to be attached which cover an\n\
            area larger than the ScrollablePane itself and these child windows can be\n\
            scrolled into view using the scrollbars of the scrollable pane.\n\
        *\n", bp::init< CEGUI::String const &, CEGUI::String const & >(( bp::arg("type"), bp::arg("name") ), "! Constructor for the ScrollablePane base class.\n") );
        bp::scope ScrollablePane_scope( ScrollablePane_exposer );
        { //::CEGUI::ScrollablePane::destroy
        
            typedef void ( ::CEGUI::ScrollablePane::*destroy_function_type )(  ) ;
            typedef void ( ScrollablePane_wrapper::*default_destroy_function_type )(  ) ;
            
            ScrollablePane_exposer.def( 
                "destroy"
                , destroy_function_type(&::CEGUI::ScrollablePane::destroy)
                , default_destroy_function_type(&ScrollablePane_wrapper::default_destroy) );
        
        }
        { //::CEGUI::ScrollablePane::getContentPane
        
            typedef ::CEGUI::ScrolledContainer const * ( ::CEGUI::ScrollablePane::*getContentPane_function_type )(  ) const;
            
            ScrollablePane_exposer.def( 
                "getContentPane"
                , getContentPane_function_type( &::CEGUI::ScrollablePane::getContentPane )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
                \n\
                    Returns a pointer to the window holding the pane contents.\n\
            \n\
                    The purpose of this is so that attached windows may be inspected,\n\
                    client code may not modify the returned window in any way.\n\
            \n\
                @return\n\
                    Pointer to the ScrolledContainer that is acting as the container for the\n\
                    scrollable pane content.  The returned window is const, client code\n\
                    should not modify the ScrolledContainer settings directly.\n\
                *\n" );
        
        }
        { //::CEGUI::ScrollablePane::getContentPaneArea
        
            typedef ::CEGUI::Rect const & ( ::CEGUI::ScrollablePane::*getContentPaneArea_function_type )(  ) const;
            
            ScrollablePane_exposer.def( 
                "getContentPaneArea"
                , getContentPaneArea_function_type( &::CEGUI::ScrollablePane::getContentPaneArea )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "*!\n\
                \n\
                    Return the current content pane area for the ScrollablePane.\n\
            \n\
                @return\n\
                    Rect object that details the current pixel extents of the content\n\
                    pane attached to this ScrollablePane.\n\
                *\n" );
        
        }
        { //::CEGUI::ScrollablePane::getHorizontalOverlapSize
        
            typedef float ( ::CEGUI::ScrollablePane::*getHorizontalOverlapSize_function_type )(  ) const;
            
            ScrollablePane_exposer.def( 
                "getHorizontalOverlapSize"
                , getHorizontalOverlapSize_function_type( &::CEGUI::ScrollablePane::getHorizontalOverlapSize )
                , "*!\n\
                \n\
                    Returns the horizontal scrollbar overlap size as a fraction of one\n\
                    complete view page.\n\
            \n\
                @return\n\
                    float value specifying the overlap size where 1.0f would be the width of\n\
                    the viewing area.\n\
                *\n" );
        
        }
        { //::CEGUI::ScrollablePane::getHorizontalScrollPosition
        
            typedef float ( ::CEGUI::ScrollablePane::*getHorizontalScrollPosition_function_type )(  ) const;
            
            ScrollablePane_exposer.def( 
                "getHorizontalScrollPosition"
                , getHorizontalScrollPosition_function_type( &::CEGUI::ScrollablePane::getHorizontalScrollPosition )
                , "*!\n\
                \n\
                    Returns the horizontal scroll position as a fraction of the\n\
                    complete scrollable width.\n\
            \n\
                @return\n\
                    float value specifying the scroll position.\n\
                *\n" );
        
        }
        { //::CEGUI::ScrollablePane::getHorizontalStepSize
        
            typedef float ( ::CEGUI::ScrollablePane::*getHorizontalStepSize_function_type )(  ) const;
            
            ScrollablePane_exposer.def( 
                "getHorizontalStepSize"
                , getHorizontalStepSize_function_type( &::CEGUI::ScrollablePane::getHorizontalStepSize )
                , "*!\n\
                \n\
                    Returns the horizontal scrollbar step size as a fraction of one\n\
                    complete view page.\n\
            \n\
                @return\n\
                    float value specifying the step size where 1.0f would be the width of\n\
                    the viewing area.\n\
                *\n" );
        
        }
        { //::CEGUI::ScrollablePane::getHorzScrollbar
        
            typedef ::CEGUI::Scrollbar * ( ::CEGUI::ScrollablePane::*getHorzScrollbar_function_type )(  ) const;
            
            ScrollablePane_exposer.def( 
                "getHorzScrollbar"
                , getHorzScrollbar_function_type( &::CEGUI::ScrollablePane::getHorzScrollbar )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
                \n\
                    Return a pointer to the horizontal scrollbar component widget for\n\
                    this ScrollablePane.\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::ScrollablePane::getVertScrollbar
        
            typedef ::CEGUI::Scrollbar * ( ::CEGUI::ScrollablePane::*getVertScrollbar_function_type )(  ) const;
            
            ScrollablePane_exposer.def( 
                "getVertScrollbar"
                , getVertScrollbar_function_type( &::CEGUI::ScrollablePane::getVertScrollbar )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
                \n\
                    Return a pointer to the vertical scrollbar component widget for this\n\
                    ScrollablePane.\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::ScrollablePane::getVerticalOverlapSize
        
            typedef float ( ::CEGUI::ScrollablePane::*getVerticalOverlapSize_function_type )(  ) const;
            
            ScrollablePane_exposer.def( 
                "getVerticalOverlapSize"
                , getVerticalOverlapSize_function_type( &::CEGUI::ScrollablePane::getVerticalOverlapSize )
                , "*!\n\
                \n\
                    Returns the vertical scrollbar overlap size as a fraction of one\n\
                    complete view page.\n\
            \n\
                @return\n\
                    float value specifying the overlap size where 1.0f would be the height\n\
                    of the viewing area.\n\
                *\n" );
        
        }
        { //::CEGUI::ScrollablePane::getVerticalScrollPosition
        
            typedef float ( ::CEGUI::ScrollablePane::*getVerticalScrollPosition_function_type )(  ) const;
            
            ScrollablePane_exposer.def( 
                "getVerticalScrollPosition"
                , getVerticalScrollPosition_function_type( &::CEGUI::ScrollablePane::getVerticalScrollPosition )
                , "*!\n\
                \n\
                    Returns the vertical scroll position as a fraction of the\n\
                    complete scrollable height.\n\
            \n\
                @return\n\
                    float value specifying the scroll position.\n\
                *\n" );
        
        }
        { //::CEGUI::ScrollablePane::getVerticalStepSize
        
            typedef float ( ::CEGUI::ScrollablePane::*getVerticalStepSize_function_type )(  ) const;
            
            ScrollablePane_exposer.def( 
                "getVerticalStepSize"
                , getVerticalStepSize_function_type( &::CEGUI::ScrollablePane::getVerticalStepSize )
                , "*!\n\
                \n\
                    Returns the vertical scrollbar step size as a fraction of one\n\
                    complete view page.\n\
            \n\
                @return\n\
                    float value specifying the step size where 1.0f would be the height of\n\
                    the viewing area.\n\
                *\n" );
        
        }
        { //::CEGUI::ScrollablePane::getViewableArea
        
            typedef ::CEGUI::Rect ( ::CEGUI::ScrollablePane::*getViewableArea_function_type )(  ) const;
            
            ScrollablePane_exposer.def( 
                "getViewableArea"
                , getViewableArea_function_type( &::CEGUI::ScrollablePane::getViewableArea )
                , "*!\n\
                \n\
                    Return a Rect that described the pane's viewable area, relative\n\
                    to this Window, in pixels.\n\
            \n\
                @return\n\
                    Rect object describing the ScrollablePane's viewable area.\n\
                *\n" );
        
        }
        { //::CEGUI::ScrollablePane::initialiseComponents
        
            typedef void ( ::CEGUI::ScrollablePane::*initialiseComponents_function_type )(  ) ;
            typedef void ( ScrollablePane_wrapper::*default_initialiseComponents_function_type )(  ) ;
            
            ScrollablePane_exposer.def( 
                "initialiseComponents"
                , initialiseComponents_function_type(&::CEGUI::ScrollablePane::initialiseComponents)
                , default_initialiseComponents_function_type(&ScrollablePane_wrapper::default_initialiseComponents) );
        
        }
        { //::CEGUI::ScrollablePane::isContentPaneAutoSized
        
            typedef bool ( ::CEGUI::ScrollablePane::*isContentPaneAutoSized_function_type )(  ) const;
            
            ScrollablePane_exposer.def( 
                "isContentPaneAutoSized"
                , isContentPaneAutoSized_function_type( &::CEGUI::ScrollablePane::isContentPaneAutoSized )
                , "*!\n\
                \n\
                    Return whether the content pane is auto sized.\n\
            \n\
                @return\n\
                    - true to indicate the content pane will automatically resize itself.\n\
                    - false to indicate the content pane will not automatically resize\n\
                      itself.\n\
                *\n" );
        
        }
        { //::CEGUI::ScrollablePane::isHorzScrollbarAlwaysShown
        
            typedef bool ( ::CEGUI::ScrollablePane::*isHorzScrollbarAlwaysShown_function_type )(  ) const;
            
            ScrollablePane_exposer.def( 
                "isHorzScrollbarAlwaysShown"
                , isHorzScrollbarAlwaysShown_function_type( &::CEGUI::ScrollablePane::isHorzScrollbarAlwaysShown )
                , "*!\n\
                \n\
                    Return whether the horizontal scroll bar is always shown.\n\
            \n\
                @return\n\
                    - true if the scroll bar will 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::ScrollablePane::isVertScrollbarAlwaysShown
        
            typedef bool ( ::CEGUI::ScrollablePane::*isVertScrollbarAlwaysShown_function_type )(  ) const;
            
            ScrollablePane_exposer.def( 
                "isVertScrollbarAlwaysShown"
                , isVertScrollbarAlwaysShown_function_type( &::CEGUI::ScrollablePane::isVertScrollbarAlwaysShown )
                , "*!\n\
                \n\
                    Return whether the vertical scroll bar is always shown.\n\
            \n\
                @return\n\
                    - true if the scroll bar will 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::ScrollablePane::setContentPaneArea
        
            typedef void ( ::CEGUI::ScrollablePane::*setContentPaneArea_function_type )( ::CEGUI::Rect const & ) ;
            
            ScrollablePane_exposer.def( 
                "setContentPaneArea"
                , setContentPaneArea_function_type( &::CEGUI::ScrollablePane::setContentPaneArea )
                , ( bp::arg("area") )
                , "*!\n\
                \n\
                    Set the current content pane area for the ScrollablePane.\n\
            \n\
                \note\n\
                    If the ScrollablePane is configured to auto-size the content pane\n\
                    this call will have no effect.\n\
            \n\
                @param area\n\
                    Rect object that details the pixel extents to use for the content\n\
                    pane attached to this ScrollablePane.\n\
            \n\
                @return\n\
                    Nothing.\n\
                *\n" );
        
        }
        { //::CEGUI::ScrollablePane::setContentPaneAutoSized
        
            typedef void ( ::CEGUI::ScrollablePane::*setContentPaneAutoSized_function_type )( bool ) ;
            
            ScrollablePane_exposer.def( 
                "setContentPaneAutoSized"
                , setContentPaneAutoSized_function_type( &::CEGUI::ScrollablePane::setContentPaneAutoSized )
                , ( bp::arg("setting") )
                , "*!\n\
                \n\
                    Set whether the content pane should be auto-sized.\n\
            \n\
                @param setting\n\
                    - true to indicate the content pane should automatically resize itself.\n\
                    - false to indicate the content pane should not automatically resize\n\
                      itself.\n\
            \n\
                @return \n\
                    Nothing.\n\
                *\n" );
        
        }
        { //::CEGUI::ScrollablePane::setHorizontalOverlapSize
        
            typedef void ( ::CEGUI::ScrollablePane::*setHorizontalOverlapSize_function_type )( float ) ;
            
            ScrollablePane_exposer.def( 
                "setHorizontalOverlapSize"
                , setHorizontalOverlapSize_function_type( &::CEGUI::ScrollablePane::setHorizontalOverlapSize )
                , ( bp::arg("overlap") )
                , "*!\n\
                \n\
                    Sets the horizontal scrollbar overlap size as a fraction of one\n\
                    complete view page.\n\
            \n\
                @param overlap\n\
                    float value specifying the overlap size, where 1.0f would be the width\n\
                    of the viewing area.\n\
            \n\
                @return\n\
                    Nothing.\n\
                *\n" );
        
        }
        { //::CEGUI::ScrollablePane::setHorizontalScrollPosition
        
            typedef void ( ::CEGUI::ScrollablePane::*setHorizontalScrollPosition_function_type )( float ) ;
            
            ScrollablePane_exposer.def( 
                "setHorizontalScrollPosition"
                , setHorizontalScrollPosition_function_type( &::CEGUI::ScrollablePane::setHorizontalScrollPosition )
                , ( bp::arg("position") )
                , "*!\n\
                \n\
                    Sets the horizontal scroll position as a fraction of the\n\
                    complete scrollable width.\n\
            \n\
                @param position\n\
                    float value specifying the new scroll position.\n\
            \n\
                @return\n\
                    Nothing.\n\
                *\n" );
        
        }
        { //::CEGUI::ScrollablePane::setHorizontalStepSize
        
            typedef void ( ::CEGUI::ScrollablePane::*setHorizontalStepSize_function_type )( float ) ;
            
            ScrollablePane_exposer.def( 
                "setHorizontalStepSize"
                , setHorizontalStepSize_function_type( &::CEGUI::ScrollablePane::setHorizontalStepSize )
                , ( bp::arg("step") )
                , "*!\n\
                \n\
                    Sets the horizontal scrollbar step size as a fraction of one\n\
                    complete view page.\n\
            \n\
                @param step\n\
                    float value specifying the step size, where 1.0f would be the width of\n\
                    the viewing area.\n\
            \n\
                @return\n\
                    Nothing.\n\
                *\n" );
        
        }
        { //::CEGUI::ScrollablePane::setShowHorzScrollbar
        
            typedef void ( ::CEGUI::ScrollablePane::*setShowHorzScrollbar_function_type )( bool ) ;
            
            ScrollablePane_exposer.def( 
                "setShowHorzScrollbar"
                , setShowHorzScrollbar_function_type( &::CEGUI::ScrollablePane::setShowHorzScrollbar )
                , ( bp::arg("setting") )
                , "*!\n\
                \n\
                    Set whether the horizontal scroll bar should always be shown.\n\
            \n\
                @param setting\n\
                    - true if the horizontal scroll bar should be shown even when it is not\n\
                      required.\n\
                    - false if the horizontal scroll bar should only be shown when it is\n\
                      required.\n\
            \n\
                @return\n\
                    Nothing.\n\
                *\n" );
        
        }
        { //::CEGUI::ScrollablePane::setShowVertScrollbar
        
            typedef void ( ::CEGUI::ScrollablePane::*setShowVertScrollbar_function_type )( bool ) ;
            
            ScrollablePane_exposer.def( 
                "setShowVertScrollbar"
                , setShowVertScrollbar_function_type( &::CEGUI::ScrollablePane::setShowVertScrollbar )
                , ( bp::arg("setting") )
                , "*!\n\
                \n\
                    Set whether the vertical scroll bar should always be shown.\n\
            \n\
                @param setting\n\
                    - true if the vertical scroll bar should be shown even when it is not\n\
                      required.\n\
                    - false if the vertical scroll bar should only be shown when it is\n\
                      required.\n\
            \n\
                @return\n\
                    Nothing.\n\
                *\n" );
        
        }
        { //::CEGUI::ScrollablePane::setVerticalOverlapSize
        
            typedef void ( ::CEGUI::ScrollablePane::*setVerticalOverlapSize_function_type )( float ) ;
            
            ScrollablePane_exposer.def( 
                "setVerticalOverlapSize"
                , setVerticalOverlapSize_function_type( &::CEGUI::ScrollablePane::setVerticalOverlapSize )
                , ( bp::arg("overlap") )
                , "*!\n\
                \n\
                    Sets the vertical scrollbar overlap size as a fraction of one\n\
                    complete view page.\n\
            \n\
                @param overlap\n\
                    float value specifying the overlap size, where 1.0f would be the height\n\
                    of the viewing area.\n\
            \n\
                @return\n\
                    Nothing.\n\
                *\n" );
        
        }
        { //::CEGUI::ScrollablePane::setVerticalScrollPosition
        
            typedef void ( ::CEGUI::ScrollablePane::*setVerticalScrollPosition_function_type )( float ) ;
            
            ScrollablePane_exposer.def( 
                "setVerticalScrollPosition"
                , setVerticalScrollPosition_function_type( &::CEGUI::ScrollablePane::setVerticalScrollPosition )
                , ( bp::arg("position") )
                , "*!\n\
                \n\
                    Sets the vertical scroll position as a fraction of the\n\
                    complete scrollable height.\n\
            \n\
                @param position\n\
                    float value specifying the new scroll position.\n\
            \n\
                @return\n\
                    Nothing.\n\
                *\n" );
        
        }
        { //::CEGUI::ScrollablePane::setVerticalStepSize
        
            typedef void ( ::CEGUI::ScrollablePane::*setVerticalStepSize_function_type )( float ) ;
            
            ScrollablePane_exposer.def( 
                "setVerticalStepSize"
                , setVerticalStepSize_function_type( &::CEGUI::ScrollablePane::setVerticalStepSize )
                , ( bp::arg("step") )
                , "*!\n\
                \n\
                    Sets the vertical scrollbar step size as a fraction of one\n\
                    complete view page.\n\
            \n\
                @param step\n\
                    float value specifying the step size, where 1.0f would be the height of\n\
                    the viewing area.\n\
            \n\
                @return\n\
                    Nothing.\n\
                *\n" );
        
        }
        ScrollablePane_exposer.add_static_property( "EventAutoSizeSettingChanged"
                        , bp::make_getter( &CEGUI::ScrollablePane::EventAutoSizeSettingChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        ScrollablePane_exposer.add_static_property( "EventContentPaneChanged"
                        , bp::make_getter( &CEGUI::ScrollablePane::EventContentPaneChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        ScrollablePane_exposer.add_static_property( "EventContentPaneScrolled"
                        , bp::make_getter( &CEGUI::ScrollablePane::EventContentPaneScrolled
                                , bp::return_value_policy< bp::return_by_value >() ) );
        ScrollablePane_exposer.add_static_property( "EventHorzScrollbarModeChanged"
                        , bp::make_getter( &CEGUI::ScrollablePane::EventHorzScrollbarModeChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        ScrollablePane_exposer.add_static_property( "EventVertScrollbarModeChanged"
                        , bp::make_getter( &CEGUI::ScrollablePane::EventVertScrollbarModeChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        ScrollablePane_exposer.add_static_property( "HorzScrollbarNameSuffix"
                        , bp::make_getter( &CEGUI::ScrollablePane::HorzScrollbarNameSuffix
                                , bp::return_value_policy< bp::return_by_value >() ) );
        ScrollablePane_exposer.add_static_property( "ScrolledContainerNameSuffix"
                        , bp::make_getter( &CEGUI::ScrollablePane::ScrolledContainerNameSuffix
                                , bp::return_value_policy< bp::return_by_value >() ) );
        ScrollablePane_exposer.add_static_property( "VertScrollbarNameSuffix"
                        , bp::make_getter( &CEGUI::ScrollablePane::VertScrollbarNameSuffix
                                , bp::return_value_policy< bp::return_by_value >() ) );
        { //::CEGUI::Window::beginInitialisation
        
            typedef void ( ::CEGUI::Window::*beginInitialisation_function_type )(  ) ;
            typedef void ( ScrollablePane_wrapper::*default_beginInitialisation_function_type )(  ) ;
            
            ScrollablePane_exposer.def( 
                "beginInitialisation"
                , beginInitialisation_function_type(&::CEGUI::Window::beginInitialisation)
                , default_beginInitialisation_function_type(&ScrollablePane_wrapper::default_beginInitialisation) );
        
        }
        { //::CEGUI::Window::cloneChildWidgetsTo
        
            typedef void ( ::CEGUI::Window::*cloneChildWidgetsTo_function_type )( ::CEGUI::Window & ) const;
            typedef void ( ScrollablePane_wrapper::*default_cloneChildWidgetsTo_function_type )( ::CEGUI::Window & ) const;
            
            ScrollablePane_exposer.def( 
                "cloneChildWidgetsTo"
                , cloneChildWidgetsTo_function_type(&::CEGUI::Window::cloneChildWidgetsTo)
                , default_cloneChildWidgetsTo_function_type(&ScrollablePane_wrapper::default_cloneChildWidgetsTo)
                , ( bp::arg("target") ) );
        
        }
        { //::CEGUI::Window::clonePropertiesTo
        
            typedef void ( ::CEGUI::Window::*clonePropertiesTo_function_type )( ::CEGUI::Window & ) const;
            typedef void ( ScrollablePane_wrapper::*default_clonePropertiesTo_function_type )( ::CEGUI::Window & ) const;
            
            ScrollablePane_exposer.def( 
                "clonePropertiesTo"
                , clonePropertiesTo_function_type(&::CEGUI::Window::clonePropertiesTo)
                , default_clonePropertiesTo_function_type(&ScrollablePane_wrapper::default_clonePropertiesTo)
                , ( bp::arg("target") ) );
        
        }
        { //::CEGUI::Window::endInitialisation
        
            typedef void ( ::CEGUI::Window::*endInitialisation_function_type )(  ) ;
            typedef void ( ScrollablePane_wrapper::*default_endInitialisation_function_type )(  ) ;
            
            ScrollablePane_exposer.def( 
                "endInitialisation"
                , endInitialisation_function_type(&::CEGUI::Window::endInitialisation)
                , default_endInitialisation_function_type(&ScrollablePane_wrapper::default_endInitialisation) );
        
        }
        { //::CEGUI::EventSet::fireEvent
        
            typedef void ( ::CEGUI::EventSet::*fireEvent_function_type )( ::CEGUI::String const &,::CEGUI::EventArgs &,::CEGUI::String const & ) ;
            typedef void ( ScrollablePane_wrapper::*default_fireEvent_function_type )( ::CEGUI::String const &,::CEGUI::EventArgs &,::CEGUI::String const & ) ;
            
            ScrollablePane_exposer.def( 
                "fireEvent"
                , fireEvent_function_type(&::CEGUI::EventSet::fireEvent)
                , default_fireEvent_function_type(&ScrollablePane_wrapper::default_fireEvent)
                , ( bp::arg("name"), bp::arg("args"), bp::arg("eventNamespace")="" ) );
        
        }
        { //::CEGUI::Window::getRenderedStringParser
        
            typedef ::CEGUI::RenderedStringParser & ( ::CEGUI::Window::*getRenderedStringParser_function_type )(  ) const;
            
            ScrollablePane_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 ( ScrollablePane_wrapper::*default_getRenderingContext_impl_function_type )( ::CEGUI::RenderingContext & ) const;
            
            ScrollablePane_exposer.def( 
                "getRenderingContext_impl"
                , getRenderingContext_impl_function_type(&::CEGUI::Window::getRenderingContext_impl)
                , default_getRenderingContext_impl_function_type(&ScrollablePane_wrapper::default_getRenderingContext_impl)
                , ( bp::arg("ctx") ) );
        
        }
        { //::CEGUI::Window::getUnclippedInnerRect_impl
        
            typedef ::CEGUI::Rect ( ::CEGUI::Window::*getUnclippedInnerRect_impl_function_type )(  ) const;
            typedef ::CEGUI::Rect ( ScrollablePane_wrapper::*default_getUnclippedInnerRect_impl_function_type )(  ) const;
            
            ScrollablePane_exposer.def( 
                "getUnclippedInnerRect_impl"
                , getUnclippedInnerRect_impl_function_type(&::CEGUI::Window::getUnclippedInnerRect_impl)
                , default_getUnclippedInnerRect_impl_function_type(&ScrollablePane_wrapper::default_getUnclippedInnerRect_impl) );
        
        }
        { //::CEGUI::Window::isHit
        
            typedef bool ( ::CEGUI::Window::*isHit_function_type )( ::CEGUI::Vector2 const &,bool const ) const;
            typedef bool ( ScrollablePane_wrapper::*default_isHit_function_type )( ::CEGUI::Vector2 const &,bool const ) const;
            
            ScrollablePane_exposer.def( 
                "isHit"
                , isHit_function_type(&::CEGUI::Window::isHit)
                , default_isHit_function_type(&ScrollablePane_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 ( ScrollablePane_wrapper::*default_performChildWindowLayout_function_type )(  ) ;
            
            ScrollablePane_exposer.def( 
                "performChildWindowLayout"
                , performChildWindowLayout_function_type(&::CEGUI::Window::performChildWindowLayout)
                , default_performChildWindowLayout_function_type(&ScrollablePane_wrapper::default_performChildWindowLayout) );
        
        }
        { //::CEGUI::Window::setLookNFeel
        
            typedef void ( ::CEGUI::Window::*setLookNFeel_function_type )( ::CEGUI::String const & ) ;
            typedef void ( ScrollablePane_wrapper::*default_setLookNFeel_function_type )( ::CEGUI::String const & ) ;
            
            ScrollablePane_exposer.def( 
                "setLookNFeel"
                , setLookNFeel_function_type(&::CEGUI::Window::setLookNFeel)
                , default_setLookNFeel_function_type(&ScrollablePane_wrapper::default_setLookNFeel)
                , ( bp::arg("look") ) );
        
        }
        { //::CEGUI::Window::setMargin
        
            typedef void ( ::CEGUI::Window::*setMargin_function_type )( ::CEGUI::UBox const & ) ;
            typedef void ( ScrollablePane_wrapper::*default_setMargin_function_type )( ::CEGUI::UBox const & ) ;
            
            ScrollablePane_exposer.def( 
                "setMargin"
                , setMargin_function_type(&::CEGUI::Window::setMargin)
                , default_setMargin_function_type(&ScrollablePane_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 > ( ScrollablePane_wrapper::*default_subscribeScriptedEvent_function_type )( ::CEGUI::String const &,::CEGUI::String const & ) ;
            
            ScrollablePane_exposer.def( 
                "subscribeScriptedEvent"
                , subscribeScriptedEvent_function_type(&::CEGUI::EventSet::subscribeScriptedEvent)
                , default_subscribeScriptedEvent_function_type(&ScrollablePane_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 > ( ScrollablePane_wrapper::*default_subscribeScriptedEvent_function_type )( ::CEGUI::String const &,unsigned int,::CEGUI::String const & ) ;
            
            ScrollablePane_exposer.def( 
                "subscribeScriptedEvent"
                , subscribeScriptedEvent_function_type(&::CEGUI::EventSet::subscribeScriptedEvent)
                , default_subscribeScriptedEvent_function_type(&ScrollablePane_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 ( ScrollablePane_wrapper::*default_update_function_type )( float ) ;
            
            ScrollablePane_exposer.def( 
                "update"
                , update_function_type(&::CEGUI::Window::update)
                , default_update_function_type(&ScrollablePane_wrapper::default_update)
                , ( bp::arg("elapsed") ) );
        
        }
        { //::CEGUI::Window::writeXMLToStream
        
            typedef void ( ::CEGUI::Window::*writeXMLToStream_function_type )( ::CEGUI::XMLSerializer & ) const;
            typedef void ( ScrollablePane_wrapper::*default_writeXMLToStream_function_type )( ::CEGUI::XMLSerializer & ) const;
            
            ScrollablePane_exposer.def( 
                "writeXMLToStream"
                , writeXMLToStream_function_type(&::CEGUI::Window::writeXMLToStream)
                , default_writeXMLToStream_function_type(&ScrollablePane_wrapper::default_writeXMLToStream)
                , ( bp::arg("xml_stream") ) );
        
        }
    }

}
