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

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

namespace bp = boost::python;

struct ImageryComponent_wrapper : CEGUI::ImageryComponent, bp::wrapper< CEGUI::ImageryComponent > {

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

    ImageryComponent_wrapper( )
    : CEGUI::ImageryComponent( )
      , bp::wrapper< CEGUI::ImageryComponent >(){
        // null constructor
    
    }

    virtual void render_impl( ::CEGUI::Window & srcWindow, ::CEGUI::Rectf & destRect, ::CEGUI::ColourRect const * modColours, ::CEGUI::Rectf const * clipper, bool clipToDisplay ) const {
        if( bp::override func_render_impl = this->get_override( "render_impl" ) )
            func_render_impl( boost::ref(srcWindow), boost::ref(destRect), boost::python::ptr(modColours), boost::python::ptr(clipper), clipToDisplay );
        else{
            this->CEGUI::ImageryComponent::render_impl( boost::ref(srcWindow), boost::ref(destRect), boost::python::ptr(modColours), boost::python::ptr(clipper), clipToDisplay );
        }
    }
    
    virtual void default_render_impl( ::CEGUI::Window & srcWindow, ::CEGUI::Rectf & destRect, ::CEGUI::ColourRect const * modColours, ::CEGUI::Rectf const * clipper, bool clipToDisplay ) const {
        CEGUI::ImageryComponent::render_impl( boost::ref(srcWindow), boost::ref(destRect), boost::python::ptr(modColours), boost::python::ptr(clipper), clipToDisplay );
    }

    virtual bool handleFontRenderSizeChange( ::CEGUI::Window & window, ::CEGUI::Font const * font ) const  {
        if( bp::override func_handleFontRenderSizeChange = this->get_override( "handleFontRenderSizeChange" ) )
            return func_handleFontRenderSizeChange( boost::ref(window), boost::python::ptr(font) );
        else{
            return this->CEGUI::FalagardComponentBase::handleFontRenderSizeChange( boost::ref(window), boost::python::ptr(font) );
        }
    }
    
    bool default_handleFontRenderSizeChange( ::CEGUI::Window & window, ::CEGUI::Font const * font ) const  {
        return CEGUI::FalagardComponentBase::handleFontRenderSizeChange( boost::ref(window), boost::python::ptr(font) );
    }

    void initColoursRect( ::CEGUI::Window const & wnd, ::CEGUI::ColourRect const * modCols, ::CEGUI::ColourRect & cr ) const {
        CEGUI::FalagardComponentBase::initColoursRect( boost::ref(wnd), boost::python::ptr(modCols), boost::ref(cr) );
    }

    bool writeColoursXML( ::CEGUI::XMLSerializer & xml_stream ) const {
        return CEGUI::FalagardComponentBase::writeColoursXML( boost::ref(xml_stream) );
    }

};

void register_ImageryComponent_class(){

    { //::CEGUI::ImageryComponent
        typedef bp::class_< ImageryComponent_wrapper, bp::bases< CEGUI::FalagardComponentBase > > ImageryComponent_exposer_t;
        ImageryComponent_exposer_t ImageryComponent_exposer = ImageryComponent_exposer_t( "ImageryComponent", "*!\n\
        \n\
            Class that encapsulates information for a single image component.\n\
        *\n", bp::init< >("*!\n\
        \n\
            Constructor\n\
        *\n") );
        bp::scope ImageryComponent_scope( ImageryComponent_exposer );
        { //::CEGUI::ImageryComponent::getHorizontalFormatting
        
            typedef ::CEGUI::HorizontalFormatting ( ::CEGUI::ImageryComponent::*getHorizontalFormatting_function_type )( ::CEGUI::Window const & ) const;
            
            ImageryComponent_exposer.def( 
                "getHorizontalFormatting"
                , getHorizontalFormatting_function_type( &::CEGUI::ImageryComponent::getHorizontalFormatting )
                , ( bp::arg("wnd") )
                , "*!\n\
                    \n\
                        Return the current horizontal formatting setting for this ImageryComponent.\n\
            \n\
                    @return\n\
                        One of the HorizontalFormatting enumerated values.\n\
                    *\n" );
        
        }
        { //::CEGUI::ImageryComponent::getHorizontalFormattingFromComponent
        
            typedef ::CEGUI::HorizontalFormatting ( ::CEGUI::ImageryComponent::*getHorizontalFormattingFromComponent_function_type )(  ) const;
            
            ImageryComponent_exposer.def( 
                "getHorizontalFormattingFromComponent"
                , getHorizontalFormattingFromComponent_function_type( &::CEGUI::ImageryComponent::getHorizontalFormattingFromComponent )
                , "*!\n\
                    \n\
                        Directly returns the horizontal formatting which was set for the ImageryComponent.\n\
            \n\
                    @return\n\
                        The HorizontalFormatting enum.\n\
                    *\n" );
        
        }
        { //::CEGUI::ImageryComponent::getHorizontalFormattingPropertySource
        
            typedef ::CEGUI::String const & ( ::CEGUI::ImageryComponent::*getHorizontalFormattingPropertySource_function_type )(  ) const;
            
            ImageryComponent_exposer.def( 
                "getHorizontalFormattingPropertySource"
                , getHorizontalFormattingPropertySource_function_type( &::CEGUI::ImageryComponent::getHorizontalFormattingPropertySource )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "*!\n\
                    \n\
                        Returns the name of the property that will be used to obtain the horizontal\n\
                        formatting to use for this ImageryComponent or an empty string if none is set.\n\
            \n\
                    @return\n\
                        A String containing the name of the property\n\
                    *\n" );
        
        }
        { //::CEGUI::ImageryComponent::getImage
        
            typedef ::CEGUI::Image const * ( ::CEGUI::ImageryComponent::*getImage_function_type )(  ) const;
            
            ImageryComponent_exposer.def( 
                "getImage"
                , getImage_function_type( &::CEGUI::ImageryComponent::getImage )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
                    \n\
                        Return the Image object that will be drawn by this ImageryComponent.\n\
            \n\
                    @return\n\
                        Image object.\n\
                    *\n" );
        
        }
        { //::CEGUI::ImageryComponent::getImagePropertySource
        
            typedef ::CEGUI::String const & ( ::CEGUI::ImageryComponent::*getImagePropertySource_function_type )(  ) const;
            
            ImageryComponent_exposer.def( 
                "getImagePropertySource"
                , getImagePropertySource_function_type( &::CEGUI::ImageryComponent::getImagePropertySource )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "*!\n\
                    \n\
                        Return the name of the property that will be used to determine the image for this\
                        ImageryComponent.\n\
            \n\
                    @return\n\
                        String object holding the name of a Propery.\n\
                    *\n" );
        
        }
        { //::CEGUI::ImageryComponent::getVerticalFormatting
        
            typedef ::CEGUI::VerticalFormatting ( ::CEGUI::ImageryComponent::*getVerticalFormatting_function_type )( ::CEGUI::Window const & ) const;
            
            ImageryComponent_exposer.def( 
                "getVerticalFormatting"
                , getVerticalFormatting_function_type( &::CEGUI::ImageryComponent::getVerticalFormatting )
                , ( bp::arg("wnd") )
                , "*!\n\
                    \n\
                        Return the current vertical formatting setting for this ImageryComponent.\n\
            \n\
                    @return\n\
                        The VerticalFormatting enum.\n\
                    *\n" );
        
        }
        { //::CEGUI::ImageryComponent::getVerticalFormattingFromComponent
        
            typedef ::CEGUI::VerticalFormatting ( ::CEGUI::ImageryComponent::*getVerticalFormattingFromComponent_function_type )(  ) const;
            
            ImageryComponent_exposer.def( 
                "getVerticalFormattingFromComponent"
                , getVerticalFormattingFromComponent_function_type( &::CEGUI::ImageryComponent::getVerticalFormattingFromComponent )
                , "*!\n\
                    \n\
                        Directly returns the vertical formatting which was set for the ImageryComponent.\n\
            \n\
                    @return\n\
                        The VerticalFormatting enum.\n\
                    *\n" );
        
        }
        { //::CEGUI::ImageryComponent::getVerticalFormattingPropertySource
        
            typedef ::CEGUI::String const & ( ::CEGUI::ImageryComponent::*getVerticalFormattingPropertySource_function_type )(  ) const;
            
            ImageryComponent_exposer.def( 
                "getVerticalFormattingPropertySource"
                , getVerticalFormattingPropertySource_function_type( &::CEGUI::ImageryComponent::getVerticalFormattingPropertySource )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "*!\n\
                    \n\
                        Returns the name of the property that will be used to obtain the vertical\n\
                        formatting to use for this ImageryComponent or an empty string if none is set.\n\
            \n\
                    @return\n\
                        A String containing the name of the property\n\
                    *\n" );
        
        }
        { //::CEGUI::ImageryComponent::isImageFetchedFromProperty
        
            typedef bool ( ::CEGUI::ImageryComponent::*isImageFetchedFromProperty_function_type )(  ) const;
            
            ImageryComponent_exposer.def( 
                "isImageFetchedFromProperty"
                , isImageFetchedFromProperty_function_type( &::CEGUI::ImageryComponent::isImageFetchedFromProperty )
                , "*!\n\
                    \n\
                        Return whether this ImageryComponent fetches it's image via a property on the target\
                        window.\n\
            \n\
                    @return\n\
                        - true if the image comes via a Propery.\n\
                        - false if the image is defined explicitly.\n\
                    *\n" );
        
        }
        { //::CEGUI::ImageryComponent::render_impl
        
            typedef void ( ImageryComponent_wrapper::*render_impl_function_type )( ::CEGUI::Window &,::CEGUI::Rectf &,::CEGUI::ColourRect const *,::CEGUI::Rectf const *,bool ) const;
            
            ImageryComponent_exposer.def( 
                "render_impl"
                , render_impl_function_type( &ImageryComponent_wrapper::default_render_impl )
                , ( bp::arg("srcWindow"), bp::arg("destRect"), bp::arg("modColours"), bp::arg("clipper"), bp::arg("clipToDisplay") )
                , "implemets abstract from base\n" );
        
        }
        { //::CEGUI::ImageryComponent::setHorizontalFormatting
        
            typedef void ( ::CEGUI::ImageryComponent::*setHorizontalFormatting_function_type )( ::CEGUI::HorizontalFormatting ) ;
            
            ImageryComponent_exposer.def( 
                "setHorizontalFormatting"
                , setHorizontalFormatting_function_type( &::CEGUI::ImageryComponent::setHorizontalFormatting )
                , ( bp::arg("fmt") )
                , "*!\n\
                    \n\
                        Set the horizontal formatting setting for this ImageryComponent.\n\
            \n\
                    @param fmt\n\
                        One of the HorizontalFormatting enumerated values.\n\
            \n\
                    @return\n\
                        Nothing.\n\
                    *\n" );
        
        }
        { //::CEGUI::ImageryComponent::setHorizontalFormattingPropertySource
        
            typedef void ( ::CEGUI::ImageryComponent::*setHorizontalFormattingPropertySource_function_type )( ::CEGUI::String const & ) ;
            
            ImageryComponent_exposer.def( 
                "setHorizontalFormattingPropertySource"
                , setHorizontalFormattingPropertySource_function_type( &::CEGUI::ImageryComponent::setHorizontalFormattingPropertySource )
                , ( bp::arg("property_name") )
                , "*!\n\
            \n\
                Set the name of a property that will be used to obtain the horizontal\n\
                formatting to use for this ImageryComponent.\n\
            *\n" );
        
        }
        { //::CEGUI::ImageryComponent::setImage
        
            typedef void ( ::CEGUI::ImageryComponent::*setImage_function_type )( ::CEGUI::Image const * ) ;
            
            ImageryComponent_exposer.def( 
                "setImage"
                , setImage_function_type( &::CEGUI::ImageryComponent::setImage )
                , ( bp::arg("image") )
                , "*!\n\
                    \n\
                        Set the Image that will be drawn by this ImageryComponent.\n\
            \n\
                    @param\n\
                        Pointer to the Image object to be drawn by this ImageryComponent.\n\
            \n\
                    @return\n\
                        Nothing.\n\
                    *\n" );
        
        }
        { //::CEGUI::ImageryComponent::setImage
        
            typedef void ( ::CEGUI::ImageryComponent::*setImage_function_type )( ::CEGUI::String const & ) ;
            
            ImageryComponent_exposer.def( 
                "setImage"
                , setImage_function_type( &::CEGUI::ImageryComponent::setImage )
                , ( bp::arg("name") )
                , "*!\n\
                    \n\
                        Set the Image that will be drawn by this ImageryComponent.\n\
            \n\
                    @param name\n\
                        String holding the name of the Image to be rendered.\n\
            \n\
                    @return\n\
                        Nothing.\n\
                    *\n" );
        
        }
        { //::CEGUI::ImageryComponent::setImagePropertySource
        
            typedef void ( ::CEGUI::ImageryComponent::*setImagePropertySource_function_type )( ::CEGUI::String const & ) ;
            
            ImageryComponent_exposer.def( 
                "setImagePropertySource"
                , setImagePropertySource_function_type( &::CEGUI::ImageryComponent::setImagePropertySource )
                , ( bp::arg("property") )
                , "*!\n\
                    \n\
                        Set the name of the property that will be used to determine the image for this\
                        ImageryComponent.\n\
            \n\
                    @param property\n\
                        String object holding the name of a Propery.  The property should access a imageset &\
                        image specification.\n\
            \n\
                    @return\n\
                        Nothing.\n\
                    *\n" );
        
        }
        { //::CEGUI::ImageryComponent::setVerticalFormatting
        
            typedef void ( ::CEGUI::ImageryComponent::*setVerticalFormatting_function_type )( ::CEGUI::VerticalFormatting ) ;
            
            ImageryComponent_exposer.def( 
                "setVerticalFormatting"
                , setVerticalFormatting_function_type( &::CEGUI::ImageryComponent::setVerticalFormatting )
                , ( bp::arg("fmt") )
                , "*!\n\
                    \n\
                        Set the vertical formatting setting for this ImageryComponent.\n\
            \n\
                    @param fmt\n\
                        One of the VerticalFormatting enumerated values.\n\
            \n\
                    @return\n\
                        Nothing.\n\
                    *\n" );
        
        }
        { //::CEGUI::ImageryComponent::setVerticalFormattingPropertySource
        
            typedef void ( ::CEGUI::ImageryComponent::*setVerticalFormattingPropertySource_function_type )( ::CEGUI::String const & ) ;
            
            ImageryComponent_exposer.def( 
                "setVerticalFormattingPropertySource"
                , setVerticalFormattingPropertySource_function_type( &::CEGUI::ImageryComponent::setVerticalFormattingPropertySource )
                , ( bp::arg("property_name") )
                , "*!\n\
            \n\
                Set the name of a property that will be used to obtain the vertical\n\
                formatting to use for this ImageryComponent.\n\
            *\n" );
        
        }
        { //::CEGUI::ImageryComponent::writeXMLToStream
        
            typedef void ( ::CEGUI::ImageryComponent::*writeXMLToStream_function_type )( ::CEGUI::XMLSerializer & ) const;
            
            ImageryComponent_exposer.def( 
                "writeXMLToStream"
                , writeXMLToStream_function_type( &::CEGUI::ImageryComponent::writeXMLToStream )
                , ( bp::arg("xml_stream") )
                , "*!\n\
                    \n\
                        Writes an xml representation of this ImageryComponent to  out_stream.\n\
            \n\
                    @param xml_stream\n\
                        Stream where xml data should be output.\n\
            \n\
            \n\
                    @return\n\
                        Nothing.\n\
                    *\n" );
        
        }
        { //::CEGUI::FalagardComponentBase::handleFontRenderSizeChange
        
            typedef bool ( ::CEGUI::FalagardComponentBase::*handleFontRenderSizeChange_function_type )( ::CEGUI::Window &,::CEGUI::Font const * ) const;
            typedef bool ( ImageryComponent_wrapper::*default_handleFontRenderSizeChange_function_type )( ::CEGUI::Window &,::CEGUI::Font const * ) const;
            
            ImageryComponent_exposer.def( 
                "handleFontRenderSizeChange"
                , handleFontRenderSizeChange_function_type(&::CEGUI::FalagardComponentBase::handleFontRenderSizeChange)
                , default_handleFontRenderSizeChange_function_type(&ImageryComponent_wrapper::default_handleFontRenderSizeChange)
                , ( bp::arg("window"), bp::arg("font") ) );
        
        }
        { //::CEGUI::FalagardComponentBase::initColoursRect
        
            typedef void ( ImageryComponent_wrapper::*initColoursRect_function_type )( ::CEGUI::Window const &,::CEGUI::ColourRect const *,::CEGUI::ColourRect & ) const;
            
            ImageryComponent_exposer.def( 
                "initColoursRect"
                , initColoursRect_function_type( &ImageryComponent_wrapper::initColoursRect )
                , ( bp::arg("wnd"), bp::arg("modCols"), bp::arg("cr") ) );
        
        }
        { //::CEGUI::FalagardComponentBase::writeColoursXML
        
            typedef bool ( ImageryComponent_wrapper::*writeColoursXML_function_type )( ::CEGUI::XMLSerializer & ) const;
            
            ImageryComponent_exposer.def( 
                "writeColoursXML"
                , writeColoursXML_function_type( &ImageryComponent_wrapper::writeColoursXML )
                , ( bp::arg("xml_stream") )
                , "*!\n\
                \n\
                    Writes xml for the colours to a OutStream.\n\
                    Will prefer property colours before explicit.\n\
            \n\
                \note\n\
                    This is intended as a helper function for sub-classes when outputting\n\
                    xml to a stream.\n\
            \n\
                @return\n\
                    - true if xml element was written.\n\
                    - false if nothing was output due to the formatting not being set\n\
                      (sub-class may then choose to do something else.)\n\
                *\n" );
        
        }
    }

}
