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

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

namespace bp = boost::python;

struct NamedElement_wrapper : CEGUI::NamedElement, bp::wrapper< CEGUI::NamedElement > {

    NamedElement_wrapper(::CEGUI::String const & name="" )
    : CEGUI::NamedElement( boost::ref(name) )
      , bp::wrapper< CEGUI::NamedElement >(){
        // constructor
    
    }

    virtual void addChild_impl( ::CEGUI::Element * element ){
        if( bp::override func_addChild_impl = this->get_override( "addChild_impl" ) )
            func_addChild_impl( boost::python::ptr(element) );
        else{
            this->CEGUI::NamedElement::addChild_impl( boost::python::ptr(element) );
        }
    }
    
    virtual void default_addChild_impl( ::CEGUI::Element * element ){
        CEGUI::NamedElement::addChild_impl( boost::python::ptr(element) );
    }

    void addNamedElementProperties(  ){
        CEGUI::NamedElement::addNamedElementProperties(  );
    }

    virtual ::CEGUI::NamedElement * getChildByNamePath_impl( ::CEGUI::String const & name_path ) const {
        if( bp::override func_getChildByNamePath_impl = this->get_override( "getChildByNamePath_impl" ) )
            return func_getChildByNamePath_impl( boost::ref(name_path) );
        else{
            return this->CEGUI::NamedElement::getChildByNamePath_impl( boost::ref(name_path) );
        }
    }
    
    virtual ::CEGUI::NamedElement * default_getChildByNamePath_impl( ::CEGUI::String const & name_path ) const {
        return CEGUI::NamedElement::getChildByNamePath_impl( boost::ref(name_path) );
    }

    virtual ::CEGUI::NamedElement * getChildByNameRecursive_impl( ::CEGUI::String const & name ) const {
        if( bp::override func_getChildByNameRecursive_impl = this->get_override( "getChildByNameRecursive_impl" ) )
            return func_getChildByNameRecursive_impl( boost::ref(name) );
        else{
            return this->CEGUI::NamedElement::getChildByNameRecursive_impl( boost::ref(name) );
        }
    }
    
    virtual ::CEGUI::NamedElement * default_getChildByNameRecursive_impl( ::CEGUI::String const & name ) const {
        return CEGUI::NamedElement::getChildByNameRecursive_impl( boost::ref(name) );
    }

    virtual void onNameChanged( ::CEGUI::NamedElementEventArgs & e ){
        if( bp::override func_onNameChanged = this->get_override( "onNameChanged" ) )
            func_onNameChanged( boost::ref(e) );
        else{
            this->CEGUI::NamedElement::onNameChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onNameChanged( ::CEGUI::NamedElementEventArgs & e ){
        CEGUI::NamedElement::onNameChanged( boost::ref(e) );
    }

    virtual void setName( ::CEGUI::String const & name ) {
        if( bp::override func_setName = this->get_override( "setName" ) )
            func_setName( boost::ref(name) );
        else{
            this->CEGUI::NamedElement::setName( boost::ref(name) );
        }
    }
    
    void default_setName( ::CEGUI::String const & name ) {
        CEGUI::NamedElement::setName( boost::ref(name) );
    }

    void addElementProperties(  ){
        CEGUI::Element::addElementProperties(  );
    }

    void fireAreaChangeEvents( bool const moved, bool const sized ){
        CEGUI::Element::fireAreaChangeEvents( moved, sized );
    }

    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) );
    }

    void fireEvent_impl( ::CEGUI::String const & name, ::CEGUI::EventArgs & args ){
        CEGUI::EventSet::fireEvent_impl( boost::ref(name), boost::ref(args) );
    }

    ::CEGUI::ScriptModule * getScriptModule(  ) const {
        return CEGUI::EventSet::getScriptModule(  );
    }

    virtual ::CEGUI::Rectf getUnclippedInnerRect_impl( bool skipAllPixelAlignment ) const {
        if( bp::override func_getUnclippedInnerRect_impl = this->get_override( "getUnclippedInnerRect_impl" ) )
            return func_getUnclippedInnerRect_impl( skipAllPixelAlignment );
        else{
            return this->CEGUI::Element::getUnclippedInnerRect_impl( skipAllPixelAlignment );
        }
    }
    
    virtual ::CEGUI::Rectf default_getUnclippedInnerRect_impl( bool skipAllPixelAlignment ) const {
        return CEGUI::Element::getUnclippedInnerRect_impl( skipAllPixelAlignment );
    }

    virtual ::CEGUI::Rectf getUnclippedOuterRect_impl( bool skipAllPixelAlignment ) const {
        if( bp::override func_getUnclippedOuterRect_impl = this->get_override( "getUnclippedOuterRect_impl" ) )
            return func_getUnclippedOuterRect_impl( skipAllPixelAlignment );
        else{
            return this->CEGUI::Element::getUnclippedOuterRect_impl( skipAllPixelAlignment );
        }
    }
    
    virtual ::CEGUI::Rectf default_getUnclippedOuterRect_impl( bool skipAllPixelAlignment ) const {
        return CEGUI::Element::getUnclippedOuterRect_impl( skipAllPixelAlignment );
    }

    bool isInnerRectSizeChanged(  ) const {
        return CEGUI::Element::isInnerRectSizeChanged(  );
    }

    void notifyChildrenOfSizeChange( bool const non_client, bool const client ){
        CEGUI::Element::notifyChildrenOfSizeChange( non_client, client );
    }

    virtual void notifyScreenAreaChanged( bool recursive=true ) {
        if( bp::override func_notifyScreenAreaChanged = this->get_override( "notifyScreenAreaChanged" ) )
            func_notifyScreenAreaChanged( recursive );
        else{
            this->CEGUI::Element::notifyScreenAreaChanged( recursive );
        }
    }
    
    void default_notifyScreenAreaChanged( bool recursive=true ) {
        CEGUI::Element::notifyScreenAreaChanged( recursive );
    }

    virtual void onChildAdded( ::CEGUI::ElementEventArgs & e ){
        if( bp::override func_onChildAdded = this->get_override( "onChildAdded" ) )
            func_onChildAdded( boost::ref(e) );
        else{
            this->CEGUI::Element::onChildAdded( boost::ref(e) );
        }
    }
    
    virtual void default_onChildAdded( ::CEGUI::ElementEventArgs & e ){
        CEGUI::Element::onChildAdded( boost::ref(e) );
    }

    virtual void onChildRemoved( ::CEGUI::ElementEventArgs & e ){
        if( bp::override func_onChildRemoved = this->get_override( "onChildRemoved" ) )
            func_onChildRemoved( boost::ref(e) );
        else{
            this->CEGUI::Element::onChildRemoved( boost::ref(e) );
        }
    }
    
    virtual void default_onChildRemoved( ::CEGUI::ElementEventArgs & e ){
        CEGUI::Element::onChildRemoved( boost::ref(e) );
    }

    virtual void onHorizontalAlignmentChanged( ::CEGUI::ElementEventArgs & e ){
        if( bp::override func_onHorizontalAlignmentChanged = this->get_override( "onHorizontalAlignmentChanged" ) )
            func_onHorizontalAlignmentChanged( boost::ref(e) );
        else{
            this->CEGUI::Element::onHorizontalAlignmentChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onHorizontalAlignmentChanged( ::CEGUI::ElementEventArgs & e ){
        CEGUI::Element::onHorizontalAlignmentChanged( boost::ref(e) );
    }

    virtual void onMoved( ::CEGUI::ElementEventArgs & e ){
        if( bp::override func_onMoved = this->get_override( "onMoved" ) )
            func_onMoved( boost::ref(e) );
        else{
            this->CEGUI::Element::onMoved( boost::ref(e) );
        }
    }
    
    virtual void default_onMoved( ::CEGUI::ElementEventArgs & e ){
        CEGUI::Element::onMoved( boost::ref(e) );
    }

    virtual void onNonClientChanged( ::CEGUI::ElementEventArgs & e ){
        if( bp::override func_onNonClientChanged = this->get_override( "onNonClientChanged" ) )
            func_onNonClientChanged( boost::ref(e) );
        else{
            this->CEGUI::Element::onNonClientChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onNonClientChanged( ::CEGUI::ElementEventArgs & e ){
        CEGUI::Element::onNonClientChanged( boost::ref(e) );
    }

    virtual void onParentSized( ::CEGUI::ElementEventArgs & e ){
        if( bp::override func_onParentSized = this->get_override( "onParentSized" ) )
            func_onParentSized( boost::ref(e) );
        else{
            this->CEGUI::Element::onParentSized( boost::ref(e) );
        }
    }
    
    virtual void default_onParentSized( ::CEGUI::ElementEventArgs & e ){
        CEGUI::Element::onParentSized( boost::ref(e) );
    }

    virtual void onRotated( ::CEGUI::ElementEventArgs & e ){
        if( bp::override func_onRotated = this->get_override( "onRotated" ) )
            func_onRotated( boost::ref(e) );
        else{
            this->CEGUI::Element::onRotated( boost::ref(e) );
        }
    }
    
    virtual void default_onRotated( ::CEGUI::ElementEventArgs & e ){
        CEGUI::Element::onRotated( boost::ref(e) );
    }

    virtual void onSized( ::CEGUI::ElementEventArgs & e ){
        if( bp::override func_onSized = this->get_override( "onSized" ) )
            func_onSized( boost::ref(e) );
        else{
            this->CEGUI::Element::onSized( boost::ref(e) );
        }
    }
    
    virtual void default_onSized( ::CEGUI::ElementEventArgs & e ){
        CEGUI::Element::onSized( boost::ref(e) );
    }

    virtual void onVerticalAlignmentChanged( ::CEGUI::ElementEventArgs & e ){
        if( bp::override func_onVerticalAlignmentChanged = this->get_override( "onVerticalAlignmentChanged" ) )
            func_onVerticalAlignmentChanged( boost::ref(e) );
        else{
            this->CEGUI::Element::onVerticalAlignmentChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onVerticalAlignmentChanged( ::CEGUI::ElementEventArgs & e ){
        CEGUI::Element::onVerticalAlignmentChanged( boost::ref(e) );
    }

    virtual void removeChild_impl( ::CEGUI::Element * element ){
        if( bp::override func_removeChild_impl = this->get_override( "removeChild_impl" ) )
            func_removeChild_impl( boost::python::ptr(element) );
        else{
            this->CEGUI::Element::removeChild_impl( boost::python::ptr(element) );
        }
    }
    
    virtual void default_removeChild_impl( ::CEGUI::Element * element ){
        CEGUI::Element::removeChild_impl( boost::python::ptr(element) );
    }

    virtual void setArea( ::CEGUI::UVector2 const & pos, ::CEGUI::USize const & size ) {
        if( bp::override func_setArea = this->get_override( "setArea" ) )
            func_setArea( boost::ref(pos), boost::ref(size) );
        else{
            this->CEGUI::Element::setArea( boost::ref(pos), boost::ref(size) );
        }
    }
    
    void default_setArea( ::CEGUI::UVector2 const & pos, ::CEGUI::USize const & size ) {
        CEGUI::Element::setArea( boost::ref(pos), boost::ref(size) );
    }

    virtual void setArea_impl( ::CEGUI::UVector2 const & pos, ::CEGUI::USize const & size, bool topLeftSizing=false, bool fireEvents=true ){
        if( bp::override func_setArea_impl = this->get_override( "setArea_impl" ) )
            func_setArea_impl( boost::ref(pos), boost::ref(size), topLeftSizing, fireEvents );
        else{
            this->CEGUI::Element::setArea_impl( boost::ref(pos), boost::ref(size), topLeftSizing, fireEvents );
        }
    }
    
    virtual void default_setArea_impl( ::CEGUI::UVector2 const & pos, ::CEGUI::USize const & size, bool topLeftSizing=false, bool fireEvents=true ){
        CEGUI::Element::setArea_impl( boost::ref(pos), boost::ref(size), topLeftSizing, fireEvents );
    }

    virtual void setHorizontalAlignment( ::CEGUI::HorizontalAlignment const alignment ) {
        if( bp::override func_setHorizontalAlignment = this->get_override( "setHorizontalAlignment" ) )
            func_setHorizontalAlignment( alignment );
        else{
            this->CEGUI::Element::setHorizontalAlignment( alignment );
        }
    }
    
    void default_setHorizontalAlignment( ::CEGUI::HorizontalAlignment const alignment ) {
        CEGUI::Element::setHorizontalAlignment( alignment );
    }

    virtual void setParent( ::CEGUI::Element * parent ){
        if( bp::override func_setParent = this->get_override( "setParent" ) )
            func_setParent( boost::python::ptr(parent) );
        else{
            this->CEGUI::Element::setParent( boost::python::ptr(parent) );
        }
    }
    
    virtual void default_setParent( ::CEGUI::Element * parent ){
        CEGUI::Element::setParent( boost::python::ptr(parent) );
    }

    virtual void setVerticalAlignment( ::CEGUI::VerticalAlignment const alignment ) {
        if( bp::override func_setVerticalAlignment = this->get_override( "setVerticalAlignment" ) )
            func_setVerticalAlignment( alignment );
        else{
            this->CEGUI::Element::setVerticalAlignment( alignment );
        }
    }
    
    void default_setVerticalAlignment( ::CEGUI::VerticalAlignment const alignment ) {
        CEGUI::Element::setVerticalAlignment( alignment );
    }

    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) );
    }

};

void register_NamedElement_class(){

    { //::CEGUI::NamedElement
        typedef bp::class_< NamedElement_wrapper, bp::bases< CEGUI::Element >, boost::noncopyable > NamedElement_exposer_t;
        NamedElement_exposer_t NamedElement_exposer = NamedElement_exposer_t( "NamedElement", bp::init< bp::optional< CEGUI::String const & > >(( bp::arg("name")="" ), "*!\n\
         Constructor\n\
        \n\
        @param name The initial name this element will have\n\
        *\n") );
        bp::scope NamedElement_scope( NamedElement_exposer );
        bp::implicitly_convertible< CEGUI::String const &, CEGUI::NamedElement >();
        { //::CEGUI::NamedElement::addChild_impl
        
            typedef void ( NamedElement_wrapper::*addChild_impl_function_type )( ::CEGUI::Element * ) ;
            
            NamedElement_exposer.def( 
                "addChild_impl"
                , addChild_impl_function_type( &NamedElement_wrapper::default_addChild_impl )
                , ( bp::arg("element") )
                , "! opydoc Element.addChild_impl\n" );
        
        }
        { //::CEGUI::NamedElement::addNamedElementProperties
        
            typedef void ( NamedElement_wrapper::*addNamedElementProperties_function_type )(  ) ;
            
            NamedElement_exposer.def( 
                "addNamedElementProperties"
                , addNamedElementProperties_function_type( &NamedElement_wrapper::addNamedElementProperties )
                , "*!\n\
             Add standard CEGUI.NamedElement properties.\n\
            *\n" );
        
        }
        { //::CEGUI::NamedElement::getChildByNamePath_impl
        
            typedef ::CEGUI::NamedElement * ( NamedElement_wrapper::*getChildByNamePath_impl_function_type )( ::CEGUI::String const & ) const;
            
            NamedElement_exposer.def( 
                "getChildByNamePath_impl"
                , getChildByNamePath_impl_function_type( &NamedElement_wrapper::default_getChildByNamePath_impl )
                , ( bp::arg("name_path") )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
             Retrieves a child at  name_path or 0 if none such exists\n\
            *\n" );
        
        }
        { //::CEGUI::NamedElement::getChildByNameRecursive_impl
        
            typedef ::CEGUI::NamedElement * ( NamedElement_wrapper::*getChildByNameRecursive_impl_function_type )( ::CEGUI::String const & ) const;
            
            NamedElement_exposer.def( 
                "getChildByNameRecursive_impl"
                , getChildByNameRecursive_impl_function_type( &NamedElement_wrapper::default_getChildByNameRecursive_impl )
                , ( bp::arg("name") )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
             Finds a child by  name or 0 if none such exists\n\
            *\n" );
        
        }
        { //::CEGUI::NamedElement::getChildElement
        
            typedef ::CEGUI::NamedElement * ( ::CEGUI::NamedElement::*getChildElement_function_type )( ::CEGUI::String const & ) const;
            
            NamedElement_exposer.def( 
                "getChildElement"
                , getChildElement_function_type( &::CEGUI::NamedElement::getChildElement )
                , ( bp::arg("name_path") )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
                 Return the attached child element that the given name path references.\n\
            \n\
                @param name_path\n\
                    String object holding the name path of the child element to return.\n\
            \n\
                @return\n\
                    the NamedElement object referenced by  name_path.\n\
            \n\
                @exception UnknownObjectException\n\
                    thrown if  name_path does not reference an Element attached to this\n\
                    Element.\n\
                *\n" );
        
        }
        { //::CEGUI::NamedElement::getChildElementRecursive
        
            typedef ::CEGUI::NamedElement * ( ::CEGUI::NamedElement::*getChildElementRecursive_function_type )( ::CEGUI::String const & ) const;
            
            NamedElement_exposer.def( 
                "getChildElementRecursive"
                , getChildElementRecursive_function_type( &::CEGUI::NamedElement::getChildElementRecursive )
                , ( bp::arg("name") )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
                 Find the first child with the given name, recursively and breadth-first.\n\
            \n\
                @param name\n\
                    String object holding the name of the child element to find.\n\
            \n\
                @return\n\
                    Pointer to the (first) Element object attached to this Element that has\n\
                    the name  name\n\
                *\n" );
        
        }
        { //::CEGUI::NamedElement::getName
        
            typedef ::CEGUI::String const & ( ::CEGUI::NamedElement::*getName_function_type )(  ) const;
            
            NamedElement_exposer.def( 
                "getName"
                , getName_function_type( &::CEGUI::NamedElement::getName )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "*!\n\
             Return a String object holding the name of this Element.\n\
            *\n" );
        
        }
        { //::CEGUI::NamedElement::getNamePath
        
            typedef ::CEGUI::String ( ::CEGUI::NamedElement::*getNamePath_function_type )(  ) const;
            
            NamedElement_exposer.def( 
                "getNamePath"
                , getNamePath_function_type( &::CEGUI::NamedElement::getNamePath )
                , "**\n\
             Return a String object that describes the name path for this Element.\n\
            *\n" );
        
        }
        { //::CEGUI::NamedElement::isAncestor
        
            typedef bool ( ::CEGUI::NamedElement::*isAncestor_function_type )( ::CEGUI::String const & ) const;
            
            NamedElement_exposer.def( 
                "isAncestor"
                , isAncestor_function_type( &::CEGUI::NamedElement::isAncestor )
                , ( bp::arg("name") )
                , "*!\n\
                 Return true if the specified element name is a name of some ancestor of this Element\n\
            \n\
                @param name\n\
                    String object holding the name to check for.\n\
            \n\
                @return\n\
                    - true if an element named  name is an ancestor (parent, or parent of\n\
                      parent, etc) of this element.\n\
                    - false if an element named  name is in no way an ancestor of this\n\
                      element.\n\
                *\n" );
        
        }
        { //::CEGUI::NamedElement::isChild
        
            typedef bool ( ::CEGUI::NamedElement::*isChild_function_type )( ::CEGUI::String const & ) const;
            
            NamedElement_exposer.def( 
                "isChild"
                , isChild_function_type( &::CEGUI::NamedElement::isChild )
                , ( bp::arg("name_path") )
                , "*!\n\
                 Checks whether given name path references a NamedElement that is attached to this Element.\n\
            \n\
                @param name_path\n\
                    String object holding the name path of the child element to test.\n\
            \n\
                @return\n\
                     - true if the element referenced by  name_path is attached.\n\
                     - false if the element referenced by  name_path is not attached.\n\
                *\n" );
        
        }
        { //::CEGUI::NamedElement::isChildRecursive
        
            typedef bool ( ::CEGUI::NamedElement::*isChildRecursive_function_type )( ::CEGUI::String const & ) const;
            
            NamedElement_exposer.def( 
                "isChildRecursive"
                , isChildRecursive_function_type( &::CEGUI::NamedElement::isChildRecursive )
                , ( bp::arg("name") )
                , "*!\n\
                \n\
                    returns whether at least one window with the given name is attached\n\
                    to this Window or any of it's children as a child.\n\
            \n\
                \note\n\
                    WARNING! This function can be very expensive and should only be used\n\
                    when you have no other option available. If you decide to use it anyway,\n\
                    make sure the window hierarchy from the entry point is small.\n\
            \n\
                @param ID\n\
                    uint ID code to look for.\n\
            \n\
                @return\n\
                   - true if at least one child window was found with the name  name\n\
                    - false if no child window was found with the name  name.\n\
                *\n" );
        
        }
        { //::CEGUI::NamedElement::onNameChanged
        
            typedef void ( NamedElement_wrapper::*onNameChanged_function_type )( ::CEGUI::NamedElementEventArgs & ) ;
            
            NamedElement_exposer.def( 
                "onNameChanged"
                , onNameChanged_function_type( &NamedElement_wrapper::default_onNameChanged )
                , ( bp::arg("e") )
                , "*!\n\
                 Handler called when the element's name changes.\n\
            \n\
                @param e\n\
                    NamedElementEventArgs object whose 'element' pointer field is set to the element\n\
                    that triggered the event. For this event the trigger element is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::NamedElement::removeChild
        
            typedef void ( ::CEGUI::NamedElement::*removeChild_function_type )( ::CEGUI::String const & ) ;
            
            NamedElement_exposer.def( 
                "removeChild"
                , removeChild_function_type( &::CEGUI::NamedElement::removeChild )
                , ( bp::arg("name_path") )
                , "*!\n\
                \n\
                    Remove the Element referenced by the given name path from this Element's\n\
                    child list.\n\
            \n\
                @param name_path\n\
                    String the name path that references the the Element to be removed.\n\
                    If the Element specified is not attached to this Window,\n\
                    UnknownObjectException is thrown\n\
                *\n" );
        
        }
        { //::CEGUI::NamedElement::setName
        
            typedef void ( ::CEGUI::NamedElement::*setName_function_type )( ::CEGUI::String const & ) ;
            typedef void ( NamedElement_wrapper::*default_setName_function_type )( ::CEGUI::String const & ) ;
            
            NamedElement_exposer.def( 
                "setName"
                , setName_function_type(&::CEGUI::NamedElement::setName)
                , default_setName_function_type(&NamedElement_wrapper::default_setName)
                , ( bp::arg("name") ) );
        
        }
        NamedElement_exposer.add_static_property( "EventNameChanged"
                        , bp::make_getter( &CEGUI::NamedElement::EventNameChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        { //::CEGUI::Element::addElementProperties
        
            typedef void ( NamedElement_wrapper::*addElementProperties_function_type )(  ) ;
            
            NamedElement_exposer.def( 
                "addElementProperties"
                , addElementProperties_function_type( &NamedElement_wrapper::addElementProperties )
                , "*!\n\
            \n\
                Add standard CEGUI.Element properties.\n\
            *\n" );
        
        }
        { //::CEGUI::Element::fireAreaChangeEvents
        
            typedef void ( NamedElement_wrapper::*fireAreaChangeEvents_function_type )( bool const,bool const ) ;
            
            NamedElement_exposer.def( 
                "fireAreaChangeEvents"
                , fireAreaChangeEvents_function_type( &NamedElement_wrapper::fireAreaChangeEvents )
                , ( bp::arg("moved"), bp::arg("sized") )
                , "! helper to fire events based on changes to area rect\n" );
        
        }
        { //::CEGUI::EventSet::fireEvent
        
            typedef void ( ::CEGUI::EventSet::*fireEvent_function_type )( ::CEGUI::String const &,::CEGUI::EventArgs &,::CEGUI::String const & ) ;
            typedef void ( NamedElement_wrapper::*default_fireEvent_function_type )( ::CEGUI::String const &,::CEGUI::EventArgs &,::CEGUI::String const & ) ;
            
            NamedElement_exposer.def( 
                "fireEvent"
                , fireEvent_function_type(&::CEGUI::EventSet::fireEvent)
                , default_fireEvent_function_type(&NamedElement_wrapper::default_fireEvent)
                , ( bp::arg("name"), bp::arg("args"), bp::arg("eventNamespace")="" ) );
        
        }
        { //::CEGUI::EventSet::fireEvent_impl
        
            typedef void ( NamedElement_wrapper::*fireEvent_impl_function_type )( ::CEGUI::String const &,::CEGUI::EventArgs & ) ;
            
            NamedElement_exposer.def( 
                "fireEvent_impl"
                , fireEvent_impl_function_type( &NamedElement_wrapper::fireEvent_impl )
                , ( bp::arg("name"), bp::arg("args") )
                , "! Implementation event firing member\n" );
        
        }
        { //::CEGUI::Element::getClientChildContentArea
        
            typedef ::CEGUI::Element::CachedRectf const & ( ::CEGUI::Element::*getClientChildContentArea_function_type )(  ) const;
            
            NamedElement_exposer.def( 
                "getClientChildContentArea"
                , getClientChildContentArea_function_type(&::CEGUI::Element::getClientChildContentArea)
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::CEGUI::Element::getNonClientChildContentArea
        
            typedef ::CEGUI::Element::CachedRectf const & ( ::CEGUI::Element::*getNonClientChildContentArea_function_type )(  ) const;
            
            NamedElement_exposer.def( 
                "getNonClientChildContentArea"
                , getNonClientChildContentArea_function_type(&::CEGUI::Element::getNonClientChildContentArea)
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::CEGUI::Element::getRootContainerSize
        
            typedef ::CEGUI::Sizef const & ( ::CEGUI::Element::*getRootContainerSize_function_type )(  ) const;
            
            NamedElement_exposer.def( 
                "getRootContainerSize"
                , getRootContainerSize_function_type(&::CEGUI::Element::getRootContainerSize)
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::CEGUI::EventSet::getScriptModule
        
            typedef ::CEGUI::ScriptModule * ( NamedElement_wrapper::*getScriptModule_function_type )(  ) const;
            
            NamedElement_exposer.def( 
                "getScriptModule"
                , getScriptModule_function_type( &NamedElement_wrapper::getScriptModule )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "! Implementation event firing member\n\
            ! Helper to return the script module pointer or throw.\n" );
        
        }
        { //::CEGUI::Element::getUnclippedInnerRect_impl
        
            typedef ::CEGUI::Rectf ( NamedElement_wrapper::*getUnclippedInnerRect_impl_function_type )( bool ) const;
            
            NamedElement_exposer.def( 
                "getUnclippedInnerRect_impl"
                , getUnclippedInnerRect_impl_function_type( &NamedElement_wrapper::default_getUnclippedInnerRect_impl )
                , ( bp::arg("skipAllPixelAlignment") )
                , "! Default implementation of function to return Element's outer rect area.\n\
            ! Default implementation of function to return Element's inner rect area.\n" );
        
        }
        { //::CEGUI::Element::getUnclippedOuterRect_impl
        
            typedef ::CEGUI::Rectf ( NamedElement_wrapper::*getUnclippedOuterRect_impl_function_type )( bool ) const;
            
            NamedElement_exposer.def( 
                "getUnclippedOuterRect_impl"
                , getUnclippedOuterRect_impl_function_type( &NamedElement_wrapper::default_getUnclippedOuterRect_impl )
                , ( bp::arg("skipAllPixelAlignment") )
                , "! Default implementation of function to return Element's outer rect area.\n" );
        
        }
        { //::CEGUI::Element::isInnerRectSizeChanged
        
            typedef bool ( NamedElement_wrapper::*isInnerRectSizeChanged_function_type )(  ) const;
            
            NamedElement_exposer.def( 
                "isInnerRectSizeChanged"
                , isInnerRectSizeChanged_function_type( &NamedElement_wrapper::isInnerRectSizeChanged )
                , "! helper to return whether the inner rect size has changed\n" );
        
        }
        { //::CEGUI::Element::notifyChildrenOfSizeChange
        
            typedef void ( NamedElement_wrapper::*notifyChildrenOfSizeChange_function_type )( bool const,bool const ) ;
            
            NamedElement_exposer.def( 
                "notifyChildrenOfSizeChange"
                , notifyChildrenOfSizeChange_function_type( &NamedElement_wrapper::notifyChildrenOfSizeChange )
                , ( bp::arg("non_client"), bp::arg("client") ) );
        
        }
        { //::CEGUI::Element::notifyScreenAreaChanged
        
            typedef void ( ::CEGUI::Element::*notifyScreenAreaChanged_function_type )( bool ) ;
            typedef void ( NamedElement_wrapper::*default_notifyScreenAreaChanged_function_type )( bool ) ;
            
            NamedElement_exposer.def( 
                "notifyScreenAreaChanged"
                , notifyScreenAreaChanged_function_type(&::CEGUI::Element::notifyScreenAreaChanged)
                , default_notifyScreenAreaChanged_function_type(&NamedElement_wrapper::default_notifyScreenAreaChanged)
                , ( bp::arg("recursive")=(bool)(true) ) );
        
        }
        { //::CEGUI::Element::onChildAdded
        
            typedef void ( NamedElement_wrapper::*onChildAdded_function_type )( ::CEGUI::ElementEventArgs & ) ;
            
            NamedElement_exposer.def( 
                "onChildAdded"
                , onChildAdded_function_type( &NamedElement_wrapper::default_onChildAdded )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when a child element is added to this element.\n\
            \n\
                @param e\n\
                    ElementEventArgs object whose 'element' pointer field is set to the element\n\
                    that has been added.\n\
                *\n" );
        
        }
        { //::CEGUI::Element::onChildRemoved
        
            typedef void ( NamedElement_wrapper::*onChildRemoved_function_type )( ::CEGUI::ElementEventArgs & ) ;
            
            NamedElement_exposer.def( 
                "onChildRemoved"
                , onChildRemoved_function_type( &NamedElement_wrapper::default_onChildRemoved )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when a child element is removed from this element.\n\
            \n\
                @param e\n\
                    ElementEventArgs object whose 'element' pointer field is set the element\n\
                    that has been removed.\n\
                *\n" );
        
        }
        { //::CEGUI::Element::onHorizontalAlignmentChanged
        
            typedef void ( NamedElement_wrapper::*onHorizontalAlignmentChanged_function_type )( ::CEGUI::ElementEventArgs & ) ;
            
            NamedElement_exposer.def( 
                "onHorizontalAlignmentChanged"
                , onHorizontalAlignmentChanged_function_type( &NamedElement_wrapper::default_onHorizontalAlignmentChanged )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the horizontal alignment setting for the element is\n\
                    changed.\n\
            \n\
                @param e\n\
                    ElementEventArgs object initialised as follows:\n\
                    - element field is set to point to the element object who's alignment has\n\
                      changed (typically 'this').\n\
                *\n" );
        
        }
        { //::CEGUI::Element::onMoved
        
            typedef void ( NamedElement_wrapper::*onMoved_function_type )( ::CEGUI::ElementEventArgs & ) ;
            
            NamedElement_exposer.def( 
                "onMoved"
                , onMoved_function_type( &NamedElement_wrapper::default_onMoved )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the element's position changes.\n\
            \n\
                @param e\n\
                    ElementEventArgs object whose 'element' pointer field is set to the element\n\
                    that triggered the event.\n\
                *\n" );
        
        }
        { //::CEGUI::Element::onNonClientChanged
        
            typedef void ( NamedElement_wrapper::*onNonClientChanged_function_type )( ::CEGUI::ElementEventArgs & ) ;
            
            NamedElement_exposer.def( 
                "onNonClientChanged"
                , onNonClientChanged_function_type( &NamedElement_wrapper::default_onNonClientChanged )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the element's non-client setting, affecting it's\n\
                    position and size relative to it's parent is changed.\n\
            \n\
                @param e\n\
                    ElementEventArgs object whose 'element' pointer field is set to the element\n\
                    that triggered the event. For this event the trigger element is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::Element::onParentSized
        
            typedef void ( NamedElement_wrapper::*onParentSized_function_type )( ::CEGUI::ElementEventArgs & ) ;
            
            NamedElement_exposer.def( 
                "onParentSized"
                , onParentSized_function_type( &NamedElement_wrapper::default_onParentSized )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when this element's parent element has been resized.  If\n\
                    this element is the root  GUI Sheet element, this call will be made when\n\
                    the display size changes.\n\
            \n\
                @param e\n\
                    ElementEventArgs object whose 'element' pointer field is set the the\n\
                    element that caused the event; this is typically either this element's\n\
                    parent element, or NULL to indicate the screen size has changed.\n\
                *\n" );
        
        }
        { //::CEGUI::Element::onRotated
        
            typedef void ( NamedElement_wrapper::*onRotated_function_type )( ::CEGUI::ElementEventArgs & ) ;
            
            NamedElement_exposer.def( 
                "onRotated"
                , onRotated_function_type( &NamedElement_wrapper::default_onRotated )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the element's rotation is changed.\n\
            \n\
                @param e\n\
                    ElementEventArgs object whose 'element' pointer field is set to the element\n\
                    that triggered the event.\n\
                *\n" );
        
        }
        { //::CEGUI::Element::onSized
        
            typedef void ( NamedElement_wrapper::*onSized_function_type )( ::CEGUI::ElementEventArgs & ) ;
            
            NamedElement_exposer.def( 
                "onSized"
                , onSized_function_type( &NamedElement_wrapper::default_onSized )
                , ( bp::arg("e") )
                , "*************************************************************************\n\
                    Event trigger methods\n\
                *************************************************************************\n\
                *!\n\
                \n\
                    Handler called when the element's size changes.\n\
            \n\
                @param e\n\
                    ElementEventArgs object whose 'element' pointer field is set to the element\n\
                    that triggered the event.\n\
                *\n" );
        
        }
        { //::CEGUI::Element::onVerticalAlignmentChanged
        
            typedef void ( NamedElement_wrapper::*onVerticalAlignmentChanged_function_type )( ::CEGUI::ElementEventArgs & ) ;
            
            NamedElement_exposer.def( 
                "onVerticalAlignmentChanged"
                , onVerticalAlignmentChanged_function_type( &NamedElement_wrapper::default_onVerticalAlignmentChanged )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the vertical alignment setting for the element is\n\
                    changed.\n\
            \n\
                @param e\n\
                    ElementEventArgs object initialised as follows:\n\
                    - element field is set to point to the element object who's alignment has\n\
                      changed (typically 'this').\n\
                *\n" );
        
        }
        { //::CEGUI::Element::removeChild_impl
        
            typedef void ( NamedElement_wrapper::*removeChild_impl_function_type )( ::CEGUI::Element * ) ;
            
            NamedElement_exposer.def( 
                "removeChild_impl"
                , removeChild_impl_function_type( &NamedElement_wrapper::default_removeChild_impl )
                , ( bp::arg("element") )
                , "*!\n\
            \n\
                Remove given element from child list\n\
            *\n" );
        
        }
        { //::CEGUI::Element::setArea
        
            typedef void ( ::CEGUI::Element::*setArea_function_type )( ::CEGUI::UVector2 const &,::CEGUI::USize const & ) ;
            typedef void ( NamedElement_wrapper::*default_setArea_function_type )( ::CEGUI::UVector2 const &,::CEGUI::USize const & ) ;
            
            NamedElement_exposer.def( 
                "setArea"
                , setArea_function_type(&::CEGUI::Element::setArea)
                , default_setArea_function_type(&NamedElement_wrapper::default_setArea)
                , ( bp::arg("pos"), bp::arg("size") ) );
        
        }
        { //::CEGUI::Element::setArea
        
            typedef void ( ::CEGUI::Element::*setArea_function_type )( ::CEGUI::UDim const &,::CEGUI::UDim const &,::CEGUI::UDim const &,::CEGUI::UDim const & ) ;
            
            NamedElement_exposer.def( 
                "setArea"
                , setArea_function_type( &::CEGUI::Element::setArea )
                , ( bp::arg("xpos"), bp::arg("ypos"), bp::arg("width"), bp::arg("height") )
                , "!  overload\n" );
        
        }
        { //::CEGUI::Element::setArea
        
            typedef void ( ::CEGUI::Element::*setArea_function_type )( ::CEGUI::URect const & ) ;
            
            NamedElement_exposer.def( 
                "setArea"
                , setArea_function_type( &::CEGUI::Element::setArea )
                , ( bp::arg("area") )
                , "!  overload\n" );
        
        }
        { //::CEGUI::Element::setArea_impl
        
            typedef void ( NamedElement_wrapper::*setArea_impl_function_type )( ::CEGUI::UVector2 const &,::CEGUI::USize const &,bool,bool ) ;
            
            NamedElement_exposer.def( 
                "setArea_impl"
                , setArea_impl_function_type( &NamedElement_wrapper::default_setArea_impl )
                , ( bp::arg("pos"), bp::arg("size"), bp::arg("topLeftSizing")=(bool)(false), bp::arg("fireEvents")=(bool)(true) )
                , "*!\n\
                \n\
                    Implementation method to modify element area while correctly applying\n\
                    min  max size processing, and firing any appropriate events.\n\
            \n\
                \note\n\
                    This is the implementation function for setting size and position.\n\
                    In order to simplify area management, from this point on, all\n\
                    modifications to element size and position (area rect) should come\n\
                    through here.\n\
            \n\
                @param pos\n\
                    UVector2 object describing the new area position.\n\
            \n\
                @param size\n\
                    USize object describing the new area size.\n\
            \n\
                @param topLeftSizing\n\
                    - true to indicate the the operation is a sizing operation on the top\n\
                      andor left edges of the area, and so element movement should be\n\
                      inhibited if size is at max or min.\n\
                    - false to indicate the operation is not a strict sizing operation on\n\
                      the top andor left edges and that the element position may change as\n\
                      required\n\
            \n\
                @param fireEvents\n\
                    - true if events should be fired as normal.\n\
                    - false to inhibit firing of events (required, for example, if you need\n\
                      to call this from the onSizeonMove handlers).\n\
                 *\n" );
        
        }
        { //::CEGUI::Element::setHorizontalAlignment
        
            typedef void ( ::CEGUI::Element::*setHorizontalAlignment_function_type )( ::CEGUI::HorizontalAlignment const ) ;
            typedef void ( NamedElement_wrapper::*default_setHorizontalAlignment_function_type )( ::CEGUI::HorizontalAlignment const ) ;
            
            NamedElement_exposer.def( 
                "setHorizontalAlignment"
                , setHorizontalAlignment_function_type(&::CEGUI::Element::setHorizontalAlignment)
                , default_setHorizontalAlignment_function_type(&NamedElement_wrapper::default_setHorizontalAlignment)
                , ( bp::arg("alignment") ) );
        
        }
        { //::CEGUI::Element::setParent
        
            typedef void ( NamedElement_wrapper::*setParent_function_type )( ::CEGUI::Element * ) ;
            
            NamedElement_exposer.def( 
                "setParent"
                , setParent_function_type( &NamedElement_wrapper::default_setParent )
                , ( bp::arg("parent") )
                , "*!\n\
                \n\
                    Set the parent element for this element object.\n\
            \n\
                @param parent\n\
                    Pointer to a Element object that is to be assigned as the parent to this\n\
                    Element.\n\
            \n\
                @return\n\
                    Nothing\n\
                *\n" );
        
        }
        { //::CEGUI::Element::setVerticalAlignment
        
            typedef void ( ::CEGUI::Element::*setVerticalAlignment_function_type )( ::CEGUI::VerticalAlignment const ) ;
            typedef void ( NamedElement_wrapper::*default_setVerticalAlignment_function_type )( ::CEGUI::VerticalAlignment const ) ;
            
            NamedElement_exposer.def( 
                "setVerticalAlignment"
                , setVerticalAlignment_function_type(&::CEGUI::Element::setVerticalAlignment)
                , default_setVerticalAlignment_function_type(&NamedElement_wrapper::default_setVerticalAlignment)
                , ( bp::arg("alignment") ) );
        
        }
        { //::CEGUI::EventSet::subscribeScriptedEvent
        
            typedef ::CEGUI::RefCounted< CEGUI::BoundSlot > ( ::CEGUI::EventSet::*subscribeScriptedEvent_function_type )( ::CEGUI::String const &,::CEGUI::String const & ) ;
            typedef ::CEGUI::RefCounted< CEGUI::BoundSlot > ( NamedElement_wrapper::*default_subscribeScriptedEvent_function_type )( ::CEGUI::String const &,::CEGUI::String const & ) ;
            
            NamedElement_exposer.def( 
                "subscribeScriptedEvent"
                , subscribeScriptedEvent_function_type(&::CEGUI::EventSet::subscribeScriptedEvent)
                , default_subscribeScriptedEvent_function_type(&NamedElement_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 > ( NamedElement_wrapper::*default_subscribeScriptedEvent_function_type )( ::CEGUI::String const &,unsigned int,::CEGUI::String const & ) ;
            
            NamedElement_exposer.def( 
                "subscribeScriptedEvent"
                , subscribeScriptedEvent_function_type(&::CEGUI::EventSet::subscribeScriptedEvent)
                , default_subscribeScriptedEvent_function_type(&NamedElement_wrapper::default_subscribeScriptedEvent)
                , ( bp::arg("name"), bp::arg("group"), bp::arg("subscriber_name") ) );
        
        }
    }

}
