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

#include "boost/python.hpp"
#include "generators/include/python_CEGUI.h"
#include "BasicImage.pypp.hpp"

namespace bp = boost::python;

struct BasicImage_wrapper : CEGUI::BasicImage, bp::wrapper< CEGUI::BasicImage > {

    BasicImage_wrapper(CEGUI::BasicImage const & arg )
    : CEGUI::BasicImage( arg )
      , bp::wrapper< CEGUI::BasicImage >(){
        // copy constructor
        
    }

    BasicImage_wrapper(::CEGUI::String const & name )
    : CEGUI::BasicImage( boost::ref(name) )
      , bp::wrapper< CEGUI::BasicImage >(){
        // constructor
    
    }

    BasicImage_wrapper(::CEGUI::XMLAttributes const & attributes )
    : CEGUI::BasicImage( boost::ref(attributes) )
      , bp::wrapper< CEGUI::BasicImage >(){
        // constructor
    
    }

    BasicImage_wrapper(::CEGUI::String const & name, ::CEGUI::Texture * texture, ::CEGUI::Rectf const & tex_area, ::CEGUI::Vector2f const & offset, ::CEGUI::AutoScaledMode const autoscaled, ::CEGUI::Sizef const & native_res )
    : CEGUI::BasicImage( boost::ref(name), boost::python::ptr(texture), boost::ref(tex_area), boost::ref(offset), autoscaled, boost::ref(native_res) )
      , bp::wrapper< CEGUI::BasicImage >(){
        // constructor
    
    }

    virtual void notifyDisplaySizeChanged( ::CEGUI::Sizef const & renderer_display_size ) {
        if( bp::override func_notifyDisplaySizeChanged = this->get_override( "notifyDisplaySizeChanged" ) )
            func_notifyDisplaySizeChanged( boost::ref(renderer_display_size) );
        else{
            this->CEGUI::BasicImage::notifyDisplaySizeChanged( boost::ref(renderer_display_size) );
        }
    }
    
    void default_notifyDisplaySizeChanged( ::CEGUI::Sizef const & renderer_display_size ) {
        CEGUI::BasicImage::notifyDisplaySizeChanged( boost::ref(renderer_display_size) );
    }

    virtual void render( ::CEGUI::GeometryBuffer & buffer, ::CEGUI::Rectf const & dest_area, ::CEGUI::Rectf const * clip_area, ::CEGUI::ColourRect const & colours ) const  {
        if( bp::override func_render = this->get_override( "render" ) )
            func_render( boost::ref(buffer), boost::ref(dest_area), boost::python::ptr(clip_area), boost::ref(colours) );
        else{
            this->CEGUI::BasicImage::render( boost::ref(buffer), boost::ref(dest_area), boost::python::ptr(clip_area), boost::ref(colours) );
        }
    }
    
    void default_render( ::CEGUI::GeometryBuffer & buffer, ::CEGUI::Rectf const & dest_area, ::CEGUI::Rectf const * clip_area, ::CEGUI::ColourRect const & colours ) const  {
        CEGUI::BasicImage::render( boost::ref(buffer), boost::ref(dest_area), boost::python::ptr(clip_area), boost::ref(colours) );
    }

    void updateScaledOffset( ::CEGUI::Sizef const & renderer_display_size ){
        CEGUI::BasicImage::updateScaledOffset( boost::ref(renderer_display_size) );
    }

    void updateScaledSize( ::CEGUI::Sizef const & renderer_display_size ){
        CEGUI::BasicImage::updateScaledSize( boost::ref(renderer_display_size) );
    }

    void updateScaledSizeAndOffset( ::CEGUI::Sizef const & renderer_display_size ){
        CEGUI::BasicImage::updateScaledSizeAndOffset( boost::ref(renderer_display_size) );
    }

    virtual void elementEndLocal( ::CEGUI::String const & element ){
        if( bp::override func_elementEndLocal = this->get_override( "elementEndLocal" ) )
            func_elementEndLocal( boost::ref(element) );
        else{
            this->CEGUI::Image::elementEndLocal( boost::ref(element) );
        }
    }
    
    virtual void default_elementEndLocal( ::CEGUI::String const & element ){
        CEGUI::Image::elementEndLocal( boost::ref(element) );
    }

    virtual void elementStartLocal( ::CEGUI::String const & element, ::CEGUI::XMLAttributes const & attributes ){
        if( bp::override func_elementStartLocal = this->get_override( "elementStartLocal" ) )
            func_elementStartLocal( boost::ref(element), boost::ref(attributes) );
        else{
            this->CEGUI::Image::elementStartLocal( boost::ref(element), boost::ref(attributes) );
        }
    }
    
    virtual void default_elementStartLocal( ::CEGUI::String const & element, ::CEGUI::XMLAttributes const & attributes ){
        CEGUI::Image::elementStartLocal( boost::ref(element), boost::ref(attributes) );
    }

    virtual void text( ::CEGUI::String const & text ) {
        if( bp::override func_text = this->get_override( "text" ) )
            func_text( boost::ref(text) );
        else{
            this->CEGUI::XMLHandler::text( boost::ref(text) );
        }
    }
    
    void default_text( ::CEGUI::String const & text ) {
        CEGUI::XMLHandler::text( boost::ref(text) );
    }

};

void register_BasicImage_class(){

    { //::CEGUI::BasicImage
        typedef bp::class_< BasicImage_wrapper, bp::bases< CEGUI::Image > > BasicImage_exposer_t;
        BasicImage_exposer_t BasicImage_exposer = BasicImage_exposer_t( "BasicImage", bp::init< CEGUI::String const & >(( bp::arg("name") )) );
        bp::scope BasicImage_scope( BasicImage_exposer );
        bp::implicitly_convertible< CEGUI::String const &, CEGUI::BasicImage >();
        BasicImage_exposer.def( bp::init< CEGUI::XMLAttributes const & >(( bp::arg("attributes") )) );
        bp::implicitly_convertible< CEGUI::XMLAttributes const &, CEGUI::BasicImage >();
        BasicImage_exposer.def( bp::init< CEGUI::String const &, CEGUI::Texture *, CEGUI::Rectf const &, CEGUI::Vector2f const &, CEGUI::AutoScaledMode, CEGUI::Sizef const & >(( bp::arg("name"), bp::arg("texture"), bp::arg("tex_area"), bp::arg("offset"), bp::arg("autoscaled"), bp::arg("native_res") )) );
        { //::CEGUI::BasicImage::getName
        
            typedef ::CEGUI::String const & ( ::CEGUI::BasicImage::*getName_function_type )(  ) const;
            
            BasicImage_exposer.def( 
                "getName"
                , getName_function_type(&::CEGUI::BasicImage::getName)
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::CEGUI::BasicImage::getRenderedOffset
        
            typedef ::CEGUI::Vector2f const & ( ::CEGUI::BasicImage::*getRenderedOffset_function_type )(  ) const;
            
            BasicImage_exposer.def( 
                "getRenderedOffset"
                , getRenderedOffset_function_type(&::CEGUI::BasicImage::getRenderedOffset)
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::CEGUI::BasicImage::getRenderedSize
        
            typedef ::CEGUI::Sizef const & ( ::CEGUI::BasicImage::*getRenderedSize_function_type )(  ) const;
            
            BasicImage_exposer.def( 
                "getRenderedSize"
                , getRenderedSize_function_type(&::CEGUI::BasicImage::getRenderedSize)
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::CEGUI::BasicImage::notifyDisplaySizeChanged
        
            typedef void ( ::CEGUI::BasicImage::*notifyDisplaySizeChanged_function_type )( ::CEGUI::Sizef const & ) ;
            typedef void ( BasicImage_wrapper::*default_notifyDisplaySizeChanged_function_type )( ::CEGUI::Sizef const & ) ;
            
            BasicImage_exposer.def( 
                "notifyDisplaySizeChanged"
                , notifyDisplaySizeChanged_function_type(&::CEGUI::BasicImage::notifyDisplaySizeChanged)
                , default_notifyDisplaySizeChanged_function_type(&BasicImage_wrapper::default_notifyDisplaySizeChanged)
                , ( bp::arg("renderer_display_size") ) );
        
        }
        { //::CEGUI::BasicImage::render
        
            typedef void ( ::CEGUI::BasicImage::*render_function_type )( ::CEGUI::GeometryBuffer &,::CEGUI::Rectf const &,::CEGUI::Rectf const *,::CEGUI::ColourRect const & ) const;
            typedef void ( BasicImage_wrapper::*default_render_function_type )( ::CEGUI::GeometryBuffer &,::CEGUI::Rectf const &,::CEGUI::Rectf const *,::CEGUI::ColourRect const & ) const;
            
            BasicImage_exposer.def( 
                "render"
                , render_function_type(&::CEGUI::BasicImage::render)
                , default_render_function_type(&BasicImage_wrapper::default_render)
                , ( bp::arg("buffer"), bp::arg("dest_area"), bp::arg("clip_area"), bp::arg("colours") ) );
        
        }
        { //::CEGUI::BasicImage::setArea
        
            typedef void ( ::CEGUI::BasicImage::*setArea_function_type )( ::CEGUI::Rectf const & ) ;
            
            BasicImage_exposer.def( 
                "setArea"
                , setArea_function_type( &::CEGUI::BasicImage::setArea )
                , ( bp::arg("pixel_area") ) );
        
        }
        { //::CEGUI::BasicImage::setAutoScaled
        
            typedef void ( ::CEGUI::BasicImage::*setAutoScaled_function_type )( ::CEGUI::AutoScaledMode const ) ;
            
            BasicImage_exposer.def( 
                "setAutoScaled"
                , setAutoScaled_function_type( &::CEGUI::BasicImage::setAutoScaled )
                , ( bp::arg("autoscaled") ) );
        
        }
        { //::CEGUI::BasicImage::setNativeResolution
        
            typedef void ( ::CEGUI::BasicImage::*setNativeResolution_function_type )( ::CEGUI::Sizef const & ) ;
            
            BasicImage_exposer.def( 
                "setNativeResolution"
                , setNativeResolution_function_type( &::CEGUI::BasicImage::setNativeResolution )
                , ( bp::arg("native_res") ) );
        
        }
        { //::CEGUI::BasicImage::setOffset
        
            typedef void ( ::CEGUI::BasicImage::*setOffset_function_type )( ::CEGUI::Vector2f const & ) ;
            
            BasicImage_exposer.def( 
                "setOffset"
                , setOffset_function_type( &::CEGUI::BasicImage::setOffset )
                , ( bp::arg("pixel_offset") ) );
        
        }
        { //::CEGUI::BasicImage::setTexture
        
            typedef void ( ::CEGUI::BasicImage::*setTexture_function_type )( ::CEGUI::Texture * ) ;
            
            BasicImage_exposer.def( 
                "setTexture"
                , setTexture_function_type( &::CEGUI::BasicImage::setTexture )
                , ( bp::arg("texture") ) );
        
        }
        { //::CEGUI::BasicImage::updateScaledOffset
        
            typedef void ( BasicImage_wrapper::*updateScaledOffset_function_type )( ::CEGUI::Sizef const & ) ;
            
            BasicImage_exposer.def( 
                "updateScaledOffset"
                , updateScaledOffset_function_type( &BasicImage_wrapper::updateScaledOffset )
                , ( bp::arg("renderer_display_size") )
                , "! Updates only the scaled size values according to the new display size of the renderer \n\
            ! Updates only the scaled offset values according to the new display size of the renderer \n" );
        
        }
        { //::CEGUI::BasicImage::updateScaledSize
        
            typedef void ( BasicImage_wrapper::*updateScaledSize_function_type )( ::CEGUI::Sizef const & ) ;
            
            BasicImage_exposer.def( 
                "updateScaledSize"
                , updateScaledSize_function_type( &BasicImage_wrapper::updateScaledSize )
                , ( bp::arg("renderer_display_size") )
                , "! Updates the scaled size and offset values according to the new display size of the renderer \n\
            ! Updates only the scaled size values according to the new display size of the renderer \n" );
        
        }
        { //::CEGUI::BasicImage::updateScaledSizeAndOffset
        
            typedef void ( BasicImage_wrapper::*updateScaledSizeAndOffset_function_type )( ::CEGUI::Sizef const & ) ;
            
            BasicImage_exposer.def( 
                "updateScaledSizeAndOffset"
                , updateScaledSizeAndOffset_function_type( &BasicImage_wrapper::updateScaledSizeAndOffset )
                , ( bp::arg("renderer_display_size") )
                , "! Updates the scaled size and offset values according to the new display size of the renderer \n" );
        
        }
        { //::CEGUI::Image::elementEndLocal
        
            typedef void ( BasicImage_wrapper::*elementEndLocal_function_type )( ::CEGUI::String const & ) ;
            
            BasicImage_exposer.def( 
                "elementEndLocal"
                , elementEndLocal_function_type( &BasicImage_wrapper::default_elementEndLocal )
                , ( bp::arg("element") ) );
        
        }
        { //::CEGUI::Image::elementStartLocal
        
            typedef void ( BasicImage_wrapper::*elementStartLocal_function_type )( ::CEGUI::String const &,::CEGUI::XMLAttributes const & ) ;
            
            BasicImage_exposer.def( 
                "elementStartLocal"
                , elementStartLocal_function_type( &BasicImage_wrapper::default_elementStartLocal )
                , ( bp::arg("element"), bp::arg("attributes") )
                , "implement chained xml handler abstract interface\n" );
        
        }
        { //::CEGUI::XMLHandler::text
        
            typedef void ( ::CEGUI::XMLHandler::*text_function_type )( ::CEGUI::String const & ) ;
            typedef void ( BasicImage_wrapper::*default_text_function_type )( ::CEGUI::String const & ) ;
            
            BasicImage_exposer.def( 
                "text"
                , text_function_type(&::CEGUI::XMLHandler::text)
                , default_text_function_type(&BasicImage_wrapper::default_text)
                , ( bp::arg("text") ) );
        
        }
    }

}
