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

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

namespace bp = boost::python;

struct Combobox_wrapper : CEGUI::Combobox, bp::wrapper< CEGUI::Combobox > {

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

    bool button_PressHandler( ::CEGUI::EventArgs const & e ){
        return CEGUI::Combobox::button_PressHandler( boost::ref(e) );
    }

    bool droplist_HiddenHandler( ::CEGUI::EventArgs const & e ){
        return CEGUI::Combobox::droplist_HiddenHandler( boost::ref(e) );
    }

    bool droplist_SelectionAcceptedHandler( ::CEGUI::EventArgs const & e ){
        return CEGUI::Combobox::droplist_SelectionAcceptedHandler( boost::ref(e) );
    }

    bool editbox_CaretMovedHandler( ::CEGUI::EventArgs const & e ){
        return CEGUI::Combobox::editbox_CaretMovedHandler( boost::ref(e) );
    }

    bool editbox_EditboxFullEventHandler( ::CEGUI::EventArgs const & e ){
        return CEGUI::Combobox::editbox_EditboxFullEventHandler( boost::ref(e) );
    }

    bool editbox_MaximumTextLengthChangedHandler( ::CEGUI::EventArgs const & e ){
        return CEGUI::Combobox::editbox_MaximumTextLengthChangedHandler( boost::ref(e) );
    }

    bool editbox_MouseDownHandler( ::CEGUI::EventArgs const & e ){
        return CEGUI::Combobox::editbox_MouseDownHandler( boost::ref(e) );
    }

    bool editbox_ReadOnlyChangedHandler( ::CEGUI::EventArgs const & e ){
        return CEGUI::Combobox::editbox_ReadOnlyChangedHandler( boost::ref(e) );
    }

    bool editbox_TextAcceptedEventHandler( ::CEGUI::EventArgs const & e ){
        return CEGUI::Combobox::editbox_TextAcceptedEventHandler( boost::ref(e) );
    }

    bool editbox_TextChangedEventHandler( ::CEGUI::EventArgs const & e ){
        return CEGUI::Combobox::editbox_TextChangedEventHandler( boost::ref(e) );
    }

    bool editbox_TextSelectionChangedHandler( ::CEGUI::EventArgs const & e ){
        return CEGUI::Combobox::editbox_TextSelectionChangedHandler( boost::ref(e) );
    }

    bool editbox_TextValidityChangedHandler( ::CEGUI::EventArgs const & e ){
        return CEGUI::Combobox::editbox_TextValidityChangedHandler( boost::ref(e) );
    }

    bool editbox_ValidationStringChangedHandler( ::CEGUI::EventArgs const & e ){
        return CEGUI::Combobox::editbox_ValidationStringChangedHandler( boost::ref(e) );
    }

    virtual void initialiseComponents(  ) {
        if( bp::override func_initialiseComponents = this->get_override( "initialiseComponents" ) )
            func_initialiseComponents(  );
        else{
            this->CEGUI::Combobox::initialiseComponents(  );
        }
    }
    
    void default_initialiseComponents(  ) {
        CEGUI::Combobox::initialiseComponents( );
    }

    virtual bool isHit( ::CEGUI::Vector2f 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::Combobox::isHit( boost::ref(position), allow_disabled );
        }
    }
    
    bool default_isHit( ::CEGUI::Vector2f const & position, bool const allow_disabled=false ) const  {
        return CEGUI::Combobox::isHit( boost::ref(position), allow_disabled );
    }

    void itemSelectChangeTextUpdate( ::CEGUI::ListboxItem const * const item, bool new_state, bool old_state ){
        CEGUI::Combobox::itemSelectChangeTextUpdate( item, new_state, old_state );
    }

    bool listbox_HorzScrollModeChangedHandler( ::CEGUI::EventArgs const & e ){
        return CEGUI::Combobox::listbox_HorzScrollModeChangedHandler( boost::ref(e) );
    }

    bool listbox_ListContentsChangedHandler( ::CEGUI::EventArgs const & e ){
        return CEGUI::Combobox::listbox_ListContentsChangedHandler( boost::ref(e) );
    }

    bool listbox_ListSelectionChangedHandler( ::CEGUI::EventArgs const & e ){
        return CEGUI::Combobox::listbox_ListSelectionChangedHandler( boost::ref(e) );
    }

    bool listbox_SortModeChangedHandler( ::CEGUI::EventArgs const & e ){
        return CEGUI::Combobox::listbox_SortModeChangedHandler( boost::ref(e) );
    }

    bool listbox_VertScrollModeChangedHandler( ::CEGUI::EventArgs const & e ){
        return CEGUI::Combobox::listbox_VertScrollModeChangedHandler( boost::ref(e) );
    }

    virtual void onActivated( ::CEGUI::ActivationEventArgs & e ){
        if( bp::override func_onActivated = this->get_override( "onActivated" ) )
            func_onActivated( boost::ref(e) );
        else{
            this->CEGUI::Combobox::onActivated( boost::ref(e) );
        }
    }
    
    virtual void default_onActivated( ::CEGUI::ActivationEventArgs & e ){
        CEGUI::Combobox::onActivated( boost::ref(e) );
    }

    virtual void onCaretMoved( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onCaretMoved = this->get_override( "onCaretMoved" ) )
            func_onCaretMoved( boost::ref(e) );
        else{
            this->CEGUI::Combobox::onCaretMoved( boost::ref(e) );
        }
    }
    
    virtual void default_onCaretMoved( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Combobox::onCaretMoved( boost::ref(e) );
    }

    virtual void onDropListDisplayed( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onDropListDisplayed = this->get_override( "onDropListDisplayed" ) )
            func_onDropListDisplayed( boost::ref(e) );
        else{
            this->CEGUI::Combobox::onDropListDisplayed( boost::ref(e) );
        }
    }
    
    virtual void default_onDropListDisplayed( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Combobox::onDropListDisplayed( boost::ref(e) );
    }

    virtual void onDroplistRemoved( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onDroplistRemoved = this->get_override( "onDroplistRemoved" ) )
            func_onDroplistRemoved( boost::ref(e) );
        else{
            this->CEGUI::Combobox::onDroplistRemoved( boost::ref(e) );
        }
    }
    
    virtual void default_onDroplistRemoved( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Combobox::onDroplistRemoved( boost::ref(e) );
    }

    virtual void onEditboxFullEvent( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onEditboxFullEvent = this->get_override( "onEditboxFullEvent" ) )
            func_onEditboxFullEvent( boost::ref(e) );
        else{
            this->CEGUI::Combobox::onEditboxFullEvent( boost::ref(e) );
        }
    }
    
    virtual void default_onEditboxFullEvent( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Combobox::onEditboxFullEvent( boost::ref(e) );
    }

    virtual void onFontChanged( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onFontChanged = this->get_override( "onFontChanged" ) )
            func_onFontChanged( boost::ref(e) );
        else{
            this->CEGUI::Combobox::onFontChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onFontChanged( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Combobox::onFontChanged( boost::ref(e) );
    }

    virtual void onHorzScrollbarModeChanged( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onHorzScrollbarModeChanged = this->get_override( "onHorzScrollbarModeChanged" ) )
            func_onHorzScrollbarModeChanged( boost::ref(e) );
        else{
            this->CEGUI::Combobox::onHorzScrollbarModeChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onHorzScrollbarModeChanged( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Combobox::onHorzScrollbarModeChanged( boost::ref(e) );
    }

    virtual void onListContentsChanged( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onListContentsChanged = this->get_override( "onListContentsChanged" ) )
            func_onListContentsChanged( boost::ref(e) );
        else{
            this->CEGUI::Combobox::onListContentsChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onListContentsChanged( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Combobox::onListContentsChanged( boost::ref(e) );
    }

    virtual void onListSelectionAccepted( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onListSelectionAccepted = this->get_override( "onListSelectionAccepted" ) )
            func_onListSelectionAccepted( boost::ref(e) );
        else{
            this->CEGUI::Combobox::onListSelectionAccepted( boost::ref(e) );
        }
    }
    
    virtual void default_onListSelectionAccepted( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Combobox::onListSelectionAccepted( boost::ref(e) );
    }

    virtual void onListSelectionChanged( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onListSelectionChanged = this->get_override( "onListSelectionChanged" ) )
            func_onListSelectionChanged( boost::ref(e) );
        else{
            this->CEGUI::Combobox::onListSelectionChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onListSelectionChanged( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Combobox::onListSelectionChanged( boost::ref(e) );
    }

    virtual void onMaximumTextLengthChanged( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onMaximumTextLengthChanged = this->get_override( "onMaximumTextLengthChanged" ) )
            func_onMaximumTextLengthChanged( boost::ref(e) );
        else{
            this->CEGUI::Combobox::onMaximumTextLengthChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onMaximumTextLengthChanged( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Combobox::onMaximumTextLengthChanged( boost::ref(e) );
    }

    virtual void onReadOnlyChanged( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onReadOnlyChanged = this->get_override( "onReadOnlyChanged" ) )
            func_onReadOnlyChanged( boost::ref(e) );
        else{
            this->CEGUI::Combobox::onReadOnlyChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onReadOnlyChanged( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Combobox::onReadOnlyChanged( 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::Combobox::onSized( boost::ref(e) );
        }
    }
    
    virtual void default_onSized( ::CEGUI::ElementEventArgs & e ){
        CEGUI::Combobox::onSized( boost::ref(e) );
    }

    virtual void onSortModeChanged( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onSortModeChanged = this->get_override( "onSortModeChanged" ) )
            func_onSortModeChanged( boost::ref(e) );
        else{
            this->CEGUI::Combobox::onSortModeChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onSortModeChanged( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Combobox::onSortModeChanged( boost::ref(e) );
    }

    virtual void onTextAcceptedEvent( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onTextAcceptedEvent = this->get_override( "onTextAcceptedEvent" ) )
            func_onTextAcceptedEvent( boost::ref(e) );
        else{
            this->CEGUI::Combobox::onTextAcceptedEvent( boost::ref(e) );
        }
    }
    
    virtual void default_onTextAcceptedEvent( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Combobox::onTextAcceptedEvent( boost::ref(e) );
    }

    virtual void onTextChanged( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onTextChanged = this->get_override( "onTextChanged" ) )
            func_onTextChanged( boost::ref(e) );
        else{
            this->CEGUI::Combobox::onTextChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onTextChanged( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Combobox::onTextChanged( boost::ref(e) );
    }

    virtual void onTextSelectionChanged( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onTextSelectionChanged = this->get_override( "onTextSelectionChanged" ) )
            func_onTextSelectionChanged( boost::ref(e) );
        else{
            this->CEGUI::Combobox::onTextSelectionChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onTextSelectionChanged( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Combobox::onTextSelectionChanged( boost::ref(e) );
    }

    virtual void onTextValidityChanged( ::CEGUI::RegexMatchStateEventArgs & e ){
        if( bp::override func_onTextValidityChanged = this->get_override( "onTextValidityChanged" ) )
            func_onTextValidityChanged( boost::ref(e) );
        else{
            this->CEGUI::Combobox::onTextValidityChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onTextValidityChanged( ::CEGUI::RegexMatchStateEventArgs & e ){
        CEGUI::Combobox::onTextValidityChanged( boost::ref(e) );
    }

    virtual void onValidationStringChanged( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onValidationStringChanged = this->get_override( "onValidationStringChanged" ) )
            func_onValidationStringChanged( boost::ref(e) );
        else{
            this->CEGUI::Combobox::onValidationStringChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onValidationStringChanged( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Combobox::onValidationStringChanged( boost::ref(e) );
    }

    virtual void onVertScrollbarModeChanged( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onVertScrollbarModeChanged = this->get_override( "onVertScrollbarModeChanged" ) )
            func_onVertScrollbarModeChanged( boost::ref(e) );
        else{
            this->CEGUI::Combobox::onVertScrollbarModeChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onVertScrollbarModeChanged( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Combobox::onVertScrollbarModeChanged( boost::ref(e) );
    }

    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::Window::addChild_impl( boost::python::ptr(element) );
        }
    }
    
    virtual void default_addChild_impl( ::CEGUI::Element * element ){
        CEGUI::Window::addChild_impl( boost::python::ptr(element) );
    }

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

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

    void addWindowProperties(  ){
        CEGUI::Window::addWindowProperties(  );
    }

    void addWindowToDrawList( ::CEGUI::Window & wnd, bool at_back=false ){
        CEGUI::Window::addWindowToDrawList( boost::ref(wnd), at_back );
    }

    void allocateRenderingWindow(  ){
        CEGUI::Window::allocateRenderingWindow(  );
    }

    virtual void banPropertiesForAutoWindow(  ){
        if( bp::override func_banPropertiesForAutoWindow = this->get_override( "banPropertiesForAutoWindow" ) )
            func_banPropertiesForAutoWindow(  );
        else{
            this->CEGUI::Window::banPropertiesForAutoWindow(  );
        }
    }
    
    virtual void default_banPropertiesForAutoWindow(  ){
        CEGUI::Window::banPropertiesForAutoWindow( );
    }

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

    void bufferGeometry( ::CEGUI::RenderingContext const & ctx ){
        CEGUI::Window::bufferGeometry( boost::ref(ctx) );
    }

    virtual void cleanupChildren(  ){
        if( bp::override func_cleanupChildren = this->get_override( "cleanupChildren" ) )
            func_cleanupChildren(  );
        else{
            this->CEGUI::Window::cleanupChildren(  );
        }
    }
    
    virtual void default_cleanupChildren(  ){
        CEGUI::Window::cleanupChildren( );
    }

    virtual void cloneChildWidgetsTo( ::CEGUI::Window & target ) const  {
        if( bp::override func_cloneChildWidgetsTo = this->get_override( "cloneChildWidgetsTo" ) )
            func_cloneChildWidgetsTo( boost::ref(target) );
        else{
            this->CEGUI::Window::cloneChildWidgetsTo( boost::ref(target) );
        }
    }
    
    void default_cloneChildWidgetsTo( ::CEGUI::Window & target ) const  {
        CEGUI::Window::cloneChildWidgetsTo( boost::ref(target) );
    }

    virtual void clonePropertiesTo( ::CEGUI::Window & target ) const  {
        if( bp::override func_clonePropertiesTo = this->get_override( "clonePropertiesTo" ) )
            func_clonePropertiesTo( boost::ref(target) );
        else{
            this->CEGUI::Window::clonePropertiesTo( boost::ref(target) );
        }
    }
    
    void default_clonePropertiesTo( ::CEGUI::Window & target ) const  {
        CEGUI::Window::clonePropertiesTo( boost::ref(target) );
    }

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

    virtual void drawSelf( ::CEGUI::RenderingContext const & ctx ){
        if( bp::override func_drawSelf = this->get_override( "drawSelf" ) )
            func_drawSelf( boost::ref(ctx) );
        else{
            this->CEGUI::Window::drawSelf( boost::ref(ctx) );
        }
    }
    
    virtual void default_drawSelf( ::CEGUI::RenderingContext const & ctx ){
        CEGUI::Window::drawSelf( boost::ref(ctx) );
    }

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

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

    void generateAutoRepeatEvent( ::CEGUI::MouseButton button ){
        CEGUI::Window::generateAutoRepeatEvent( button );
    }

    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 ::CEGUI::Rectf getHitTestRect_impl(  ) const {
        if( bp::override func_getHitTestRect_impl = this->get_override( "getHitTestRect_impl" ) )
            return func_getHitTestRect_impl(  );
        else{
            return this->CEGUI::Window::getHitTestRect_impl(  );
        }
    }
    
    virtual ::CEGUI::Rectf default_getHitTestRect_impl(  ) const {
        return CEGUI::Window::getHitTestRect_impl( );
    }

    virtual ::CEGUI::Rectf getInnerRectClipper_impl(  ) const {
        if( bp::override func_getInnerRectClipper_impl = this->get_override( "getInnerRectClipper_impl" ) )
            return func_getInnerRectClipper_impl(  );
        else{
            return this->CEGUI::Window::getInnerRectClipper_impl(  );
        }
    }
    
    virtual ::CEGUI::Rectf default_getInnerRectClipper_impl(  ) const {
        return CEGUI::Window::getInnerRectClipper_impl( );
    }

    virtual ::CEGUI::Rectf getOuterRectClipper_impl(  ) const {
        if( bp::override func_getOuterRectClipper_impl = this->get_override( "getOuterRectClipper_impl" ) )
            return func_getOuterRectClipper_impl(  );
        else{
            return this->CEGUI::Window::getOuterRectClipper_impl(  );
        }
    }
    
    virtual ::CEGUI::Rectf default_getOuterRectClipper_impl(  ) const {
        return CEGUI::Window::getOuterRectClipper_impl( );
    }

    ::CEGUI::Rectf getParentElementClipIntersection( ::CEGUI::Rectf const & unclipped_area ) const {
        return CEGUI::Window::getParentElementClipIntersection( boost::ref(unclipped_area) );
    }

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

    ::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::Window::getUnclippedInnerRect_impl( skipAllPixelAlignment );
        }
    }
    
    virtual ::CEGUI::Rectf default_getUnclippedInnerRect_impl( bool skipAllPixelAlignment ) const {
        return CEGUI::Window::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 );
    }

    ::CEGUI::Window const * getWindowAttachedToCommonAncestor( ::CEGUI::Window const & wnd ) const {
        return CEGUI::Window::getWindowAttachedToCommonAncestor( boost::ref(wnd) );
    }

    virtual bool handleFontRenderSizeChange( ::CEGUI::EventArgs const & args ){
        if( bp::override func_handleFontRenderSizeChange = this->get_override( "handleFontRenderSizeChange" ) )
            return func_handleFontRenderSizeChange( boost::ref(args) );
        else{
            return this->CEGUI::Window::handleFontRenderSizeChange( boost::ref(args) );
        }
    }
    
    virtual bool default_handleFontRenderSizeChange( ::CEGUI::EventArgs const & args ){
        return CEGUI::Window::handleFontRenderSizeChange( boost::ref(args) );
    }

    void initialiseClippers( ::CEGUI::RenderingContext const & ctx ){
        CEGUI::Window::initialiseClippers( boost::ref(ctx) );
    }

    void invalidate_impl( bool const recursive ){
        CEGUI::Window::invalidate_impl( recursive );
    }

    bool isHitTargetWindow( ::CEGUI::Vector2f const & position, bool allow_disabled ) const {
        return CEGUI::Window::isHitTargetWindow( boost::ref(position), allow_disabled );
    }

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

    bool isPropertyAtDefault( ::CEGUI::Property const * property ) const {
        return CEGUI::Window::isPropertyAtDefault( boost::python::ptr(property) );
    }

    bool isTopOfZOrder(  ) const {
        return CEGUI::Window::isTopOfZOrder(  );
    }

    void layoutLookNFeelChildWidgets(  ){
        CEGUI::Window::layoutLookNFeelChildWidgets(  );
    }

    void markCachedWindowRectsInvalid(  ){
        CEGUI::Window::markCachedWindowRectsInvalid(  );
    }

    virtual bool moveToFront_impl( bool wasClicked ){
        if( bp::override func_moveToFront_impl = this->get_override( "moveToFront_impl" ) )
            return func_moveToFront_impl( wasClicked );
        else{
            return this->CEGUI::Window::moveToFront_impl( wasClicked );
        }
    }
    
    virtual bool default_moveToFront_impl( bool wasClicked ){
        return CEGUI::Window::moveToFront_impl( wasClicked );
    }

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

    void notifyClippingChanged(  ){
        CEGUI::Window::notifyClippingChanged(  );
    }

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

    virtual void onAlphaChanged( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onAlphaChanged = this->get_override( "onAlphaChanged" ) )
            func_onAlphaChanged( boost::ref(e) );
        else{
            this->CEGUI::Window::onAlphaChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onAlphaChanged( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onAlphaChanged( boost::ref(e) );
    }

    virtual void onAlwaysOnTopChanged( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onAlwaysOnTopChanged = this->get_override( "onAlwaysOnTopChanged" ) )
            func_onAlwaysOnTopChanged( boost::ref(e) );
        else{
            this->CEGUI::Window::onAlwaysOnTopChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onAlwaysOnTopChanged( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onAlwaysOnTopChanged( boost::ref(e) );
    }

    virtual void onCaptureGained( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onCaptureGained = this->get_override( "onCaptureGained" ) )
            func_onCaptureGained( boost::ref(e) );
        else{
            this->CEGUI::Window::onCaptureGained( boost::ref(e) );
        }
    }
    
    virtual void default_onCaptureGained( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onCaptureGained( boost::ref(e) );
    }

    virtual void onCaptureLost( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onCaptureLost = this->get_override( "onCaptureLost" ) )
            func_onCaptureLost( boost::ref(e) );
        else{
            this->CEGUI::Window::onCaptureLost( boost::ref(e) );
        }
    }
    
    virtual void default_onCaptureLost( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onCaptureLost( boost::ref(e) );
    }

    virtual void onCharacter( ::CEGUI::KeyEventArgs & e ){
        if( bp::override func_onCharacter = this->get_override( "onCharacter" ) )
            func_onCharacter( boost::ref(e) );
        else{
            this->CEGUI::Window::onCharacter( boost::ref(e) );
        }
    }
    
    virtual void default_onCharacter( ::CEGUI::KeyEventArgs & e ){
        CEGUI::Window::onCharacter( boost::ref(e) );
    }

    virtual void onChildAdded( ::CEGUI::ElementEventArgs & e ){
        if( bp::override func_onChildAdded = this->get_override( "onChildAdded" ) )
            func_onChildAdded( boost::ref(e) );
        else{
            this->CEGUI::Window::onChildAdded( boost::ref(e) );
        }
    }
    
    virtual void default_onChildAdded( ::CEGUI::ElementEventArgs & e ){
        CEGUI::Window::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::Window::onChildRemoved( boost::ref(e) );
        }
    }
    
    virtual void default_onChildRemoved( ::CEGUI::ElementEventArgs & e ){
        CEGUI::Window::onChildRemoved( boost::ref(e) );
    }

    virtual void onClippingChanged( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onClippingChanged = this->get_override( "onClippingChanged" ) )
            func_onClippingChanged( boost::ref(e) );
        else{
            this->CEGUI::Window::onClippingChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onClippingChanged( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onClippingChanged( boost::ref(e) );
    }

    virtual void onDeactivated( ::CEGUI::ActivationEventArgs & e ){
        if( bp::override func_onDeactivated = this->get_override( "onDeactivated" ) )
            func_onDeactivated( boost::ref(e) );
        else{
            this->CEGUI::Window::onDeactivated( boost::ref(e) );
        }
    }
    
    virtual void default_onDeactivated( ::CEGUI::ActivationEventArgs & e ){
        CEGUI::Window::onDeactivated( boost::ref(e) );
    }

    virtual void onDestructionStarted( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onDestructionStarted = this->get_override( "onDestructionStarted" ) )
            func_onDestructionStarted( boost::ref(e) );
        else{
            this->CEGUI::Window::onDestructionStarted( boost::ref(e) );
        }
    }
    
    virtual void default_onDestructionStarted( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onDestructionStarted( boost::ref(e) );
    }

    virtual void onDisabled( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onDisabled = this->get_override( "onDisabled" ) )
            func_onDisabled( boost::ref(e) );
        else{
            this->CEGUI::Window::onDisabled( boost::ref(e) );
        }
    }
    
    virtual void default_onDisabled( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onDisabled( boost::ref(e) );
    }

    virtual void onDragDropItemDropped( ::CEGUI::DragDropEventArgs & e ){
        if( bp::override func_onDragDropItemDropped = this->get_override( "onDragDropItemDropped" ) )
            func_onDragDropItemDropped( boost::ref(e) );
        else{
            this->CEGUI::Window::onDragDropItemDropped( boost::ref(e) );
        }
    }
    
    virtual void default_onDragDropItemDropped( ::CEGUI::DragDropEventArgs & e ){
        CEGUI::Window::onDragDropItemDropped( boost::ref(e) );
    }

    virtual void onDragDropItemEnters( ::CEGUI::DragDropEventArgs & e ){
        if( bp::override func_onDragDropItemEnters = this->get_override( "onDragDropItemEnters" ) )
            func_onDragDropItemEnters( boost::ref(e) );
        else{
            this->CEGUI::Window::onDragDropItemEnters( boost::ref(e) );
        }
    }
    
    virtual void default_onDragDropItemEnters( ::CEGUI::DragDropEventArgs & e ){
        CEGUI::Window::onDragDropItemEnters( boost::ref(e) );
    }

    virtual void onDragDropItemLeaves( ::CEGUI::DragDropEventArgs & e ){
        if( bp::override func_onDragDropItemLeaves = this->get_override( "onDragDropItemLeaves" ) )
            func_onDragDropItemLeaves( boost::ref(e) );
        else{
            this->CEGUI::Window::onDragDropItemLeaves( boost::ref(e) );
        }
    }
    
    virtual void default_onDragDropItemLeaves( ::CEGUI::DragDropEventArgs & e ){
        CEGUI::Window::onDragDropItemLeaves( boost::ref(e) );
    }

    virtual void onEnabled( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onEnabled = this->get_override( "onEnabled" ) )
            func_onEnabled( boost::ref(e) );
        else{
            this->CEGUI::Window::onEnabled( boost::ref(e) );
        }
    }
    
    virtual void default_onEnabled( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onEnabled( boost::ref(e) );
    }

    virtual void onHidden( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onHidden = this->get_override( "onHidden" ) )
            func_onHidden( boost::ref(e) );
        else{
            this->CEGUI::Window::onHidden( boost::ref(e) );
        }
    }
    
    virtual void default_onHidden( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onHidden( 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 onIDChanged( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onIDChanged = this->get_override( "onIDChanged" ) )
            func_onIDChanged( boost::ref(e) );
        else{
            this->CEGUI::Window::onIDChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onIDChanged( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onIDChanged( boost::ref(e) );
    }

    virtual void onInheritsAlphaChanged( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onInheritsAlphaChanged = this->get_override( "onInheritsAlphaChanged" ) )
            func_onInheritsAlphaChanged( boost::ref(e) );
        else{
            this->CEGUI::Window::onInheritsAlphaChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onInheritsAlphaChanged( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onInheritsAlphaChanged( boost::ref(e) );
    }

    virtual void onInvalidated( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onInvalidated = this->get_override( "onInvalidated" ) )
            func_onInvalidated( boost::ref(e) );
        else{
            this->CEGUI::Window::onInvalidated( boost::ref(e) );
        }
    }
    
    virtual void default_onInvalidated( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onInvalidated( boost::ref(e) );
    }

    virtual void onKeyDown( ::CEGUI::KeyEventArgs & e ){
        if( bp::override func_onKeyDown = this->get_override( "onKeyDown" ) )
            func_onKeyDown( boost::ref(e) );
        else{
            this->CEGUI::Window::onKeyDown( boost::ref(e) );
        }
    }
    
    virtual void default_onKeyDown( ::CEGUI::KeyEventArgs & e ){
        CEGUI::Window::onKeyDown( boost::ref(e) );
    }

    virtual void onKeyUp( ::CEGUI::KeyEventArgs & e ){
        if( bp::override func_onKeyUp = this->get_override( "onKeyUp" ) )
            func_onKeyUp( boost::ref(e) );
        else{
            this->CEGUI::Window::onKeyUp( boost::ref(e) );
        }
    }
    
    virtual void default_onKeyUp( ::CEGUI::KeyEventArgs & e ){
        CEGUI::Window::onKeyUp( boost::ref(e) );
    }

    virtual void onMarginChanged( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onMarginChanged = this->get_override( "onMarginChanged" ) )
            func_onMarginChanged( boost::ref(e) );
        else{
            this->CEGUI::Window::onMarginChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onMarginChanged( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onMarginChanged( boost::ref(e) );
    }

    virtual void onMouseButtonDown( ::CEGUI::MouseEventArgs & e ){
        if( bp::override func_onMouseButtonDown = this->get_override( "onMouseButtonDown" ) )
            func_onMouseButtonDown( boost::ref(e) );
        else{
            this->CEGUI::Window::onMouseButtonDown( boost::ref(e) );
        }
    }
    
    virtual void default_onMouseButtonDown( ::CEGUI::MouseEventArgs & e ){
        CEGUI::Window::onMouseButtonDown( boost::ref(e) );
    }

    virtual void onMouseButtonUp( ::CEGUI::MouseEventArgs & e ){
        if( bp::override func_onMouseButtonUp = this->get_override( "onMouseButtonUp" ) )
            func_onMouseButtonUp( boost::ref(e) );
        else{
            this->CEGUI::Window::onMouseButtonUp( boost::ref(e) );
        }
    }
    
    virtual void default_onMouseButtonUp( ::CEGUI::MouseEventArgs & e ){
        CEGUI::Window::onMouseButtonUp( boost::ref(e) );
    }

    virtual void onMouseClicked( ::CEGUI::MouseEventArgs & e ){
        if( bp::override func_onMouseClicked = this->get_override( "onMouseClicked" ) )
            func_onMouseClicked( boost::ref(e) );
        else{
            this->CEGUI::Window::onMouseClicked( boost::ref(e) );
        }
    }
    
    virtual void default_onMouseClicked( ::CEGUI::MouseEventArgs & e ){
        CEGUI::Window::onMouseClicked( boost::ref(e) );
    }

    virtual void onMouseDoubleClicked( ::CEGUI::MouseEventArgs & e ){
        if( bp::override func_onMouseDoubleClicked = this->get_override( "onMouseDoubleClicked" ) )
            func_onMouseDoubleClicked( boost::ref(e) );
        else{
            this->CEGUI::Window::onMouseDoubleClicked( boost::ref(e) );
        }
    }
    
    virtual void default_onMouseDoubleClicked( ::CEGUI::MouseEventArgs & e ){
        CEGUI::Window::onMouseDoubleClicked( boost::ref(e) );
    }

    virtual void onMouseEnters( ::CEGUI::MouseEventArgs & e ){
        if( bp::override func_onMouseEnters = this->get_override( "onMouseEnters" ) )
            func_onMouseEnters( boost::ref(e) );
        else{
            this->CEGUI::Window::onMouseEnters( boost::ref(e) );
        }
    }
    
    virtual void default_onMouseEnters( ::CEGUI::MouseEventArgs & e ){
        CEGUI::Window::onMouseEnters( boost::ref(e) );
    }

    virtual void onMouseEntersArea( ::CEGUI::MouseEventArgs & e ){
        if( bp::override func_onMouseEntersArea = this->get_override( "onMouseEntersArea" ) )
            func_onMouseEntersArea( boost::ref(e) );
        else{
            this->CEGUI::Window::onMouseEntersArea( boost::ref(e) );
        }
    }
    
    virtual void default_onMouseEntersArea( ::CEGUI::MouseEventArgs & e ){
        CEGUI::Window::onMouseEntersArea( boost::ref(e) );
    }

    virtual void onMouseLeaves( ::CEGUI::MouseEventArgs & e ){
        if( bp::override func_onMouseLeaves = this->get_override( "onMouseLeaves" ) )
            func_onMouseLeaves( boost::ref(e) );
        else{
            this->CEGUI::Window::onMouseLeaves( boost::ref(e) );
        }
    }
    
    virtual void default_onMouseLeaves( ::CEGUI::MouseEventArgs & e ){
        CEGUI::Window::onMouseLeaves( boost::ref(e) );
    }

    virtual void onMouseLeavesArea( ::CEGUI::MouseEventArgs & e ){
        if( bp::override func_onMouseLeavesArea = this->get_override( "onMouseLeavesArea" ) )
            func_onMouseLeavesArea( boost::ref(e) );
        else{
            this->CEGUI::Window::onMouseLeavesArea( boost::ref(e) );
        }
    }
    
    virtual void default_onMouseLeavesArea( ::CEGUI::MouseEventArgs & e ){
        CEGUI::Window::onMouseLeavesArea( boost::ref(e) );
    }

    virtual void onMouseMove( ::CEGUI::MouseEventArgs & e ){
        if( bp::override func_onMouseMove = this->get_override( "onMouseMove" ) )
            func_onMouseMove( boost::ref(e) );
        else{
            this->CEGUI::Window::onMouseMove( boost::ref(e) );
        }
    }
    
    virtual void default_onMouseMove( ::CEGUI::MouseEventArgs & e ){
        CEGUI::Window::onMouseMove( boost::ref(e) );
    }

    virtual void onMouseTripleClicked( ::CEGUI::MouseEventArgs & e ){
        if( bp::override func_onMouseTripleClicked = this->get_override( "onMouseTripleClicked" ) )
            func_onMouseTripleClicked( boost::ref(e) );
        else{
            this->CEGUI::Window::onMouseTripleClicked( boost::ref(e) );
        }
    }
    
    virtual void default_onMouseTripleClicked( ::CEGUI::MouseEventArgs & e ){
        CEGUI::Window::onMouseTripleClicked( boost::ref(e) );
    }

    virtual void onMouseWheel( ::CEGUI::MouseEventArgs & e ){
        if( bp::override func_onMouseWheel = this->get_override( "onMouseWheel" ) )
            func_onMouseWheel( boost::ref(e) );
        else{
            this->CEGUI::Window::onMouseWheel( boost::ref(e) );
        }
    }
    
    virtual void default_onMouseWheel( ::CEGUI::MouseEventArgs & e ){
        CEGUI::Window::onMouseWheel( 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::Window::onMoved( boost::ref(e) );
        }
    }
    
    virtual void default_onMoved( ::CEGUI::ElementEventArgs & e ){
        CEGUI::Window::onMoved( boost::ref(e) );
    }

    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 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 onParentDestroyChanged( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onParentDestroyChanged = this->get_override( "onParentDestroyChanged" ) )
            func_onParentDestroyChanged( boost::ref(e) );
        else{
            this->CEGUI::Window::onParentDestroyChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onParentDestroyChanged( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onParentDestroyChanged( 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::Window::onParentSized( boost::ref(e) );
        }
    }
    
    virtual void default_onParentSized( ::CEGUI::ElementEventArgs & e ){
        CEGUI::Window::onParentSized( boost::ref(e) );
    }

    virtual void onRenderingEnded( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onRenderingEnded = this->get_override( "onRenderingEnded" ) )
            func_onRenderingEnded( boost::ref(e) );
        else{
            this->CEGUI::Window::onRenderingEnded( boost::ref(e) );
        }
    }
    
    virtual void default_onRenderingEnded( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onRenderingEnded( boost::ref(e) );
    }

    virtual void onRenderingStarted( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onRenderingStarted = this->get_override( "onRenderingStarted" ) )
            func_onRenderingStarted( boost::ref(e) );
        else{
            this->CEGUI::Window::onRenderingStarted( boost::ref(e) );
        }
    }
    
    virtual void default_onRenderingStarted( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onRenderingStarted( 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::Window::onRotated( boost::ref(e) );
        }
    }
    
    virtual void default_onRotated( ::CEGUI::ElementEventArgs & e ){
        CEGUI::Window::onRotated( boost::ref(e) );
    }

    virtual void onShown( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onShown = this->get_override( "onShown" ) )
            func_onShown( boost::ref(e) );
        else{
            this->CEGUI::Window::onShown( boost::ref(e) );
        }
    }
    
    virtual void default_onShown( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onShown( boost::ref(e) );
    }

    virtual void onTextParsingChanged( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onTextParsingChanged = this->get_override( "onTextParsingChanged" ) )
            func_onTextParsingChanged( boost::ref(e) );
        else{
            this->CEGUI::Window::onTextParsingChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onTextParsingChanged( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onTextParsingChanged( 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 onWindowRendererAttached( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onWindowRendererAttached = this->get_override( "onWindowRendererAttached" ) )
            func_onWindowRendererAttached( boost::ref(e) );
        else{
            this->CEGUI::Window::onWindowRendererAttached( boost::ref(e) );
        }
    }
    
    virtual void default_onWindowRendererAttached( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onWindowRendererAttached( boost::ref(e) );
    }

    virtual void onWindowRendererDetached( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onWindowRendererDetached = this->get_override( "onWindowRendererDetached" ) )
            func_onWindowRendererDetached( boost::ref(e) );
        else{
            this->CEGUI::Window::onWindowRendererDetached( boost::ref(e) );
        }
    }
    
    virtual void default_onWindowRendererDetached( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onWindowRendererDetached( boost::ref(e) );
    }

    virtual void onZChange_impl(  ){
        if( bp::override func_onZChange_impl = this->get_override( "onZChange_impl" ) )
            func_onZChange_impl(  );
        else{
            this->CEGUI::Window::onZChange_impl(  );
        }
    }
    
    virtual void default_onZChange_impl(  ){
        CEGUI::Window::onZChange_impl( );
    }

    virtual void onZChanged( ::CEGUI::WindowEventArgs & e ){
        if( bp::override func_onZChanged = this->get_override( "onZChanged" ) )
            func_onZChanged( boost::ref(e) );
        else{
            this->CEGUI::Window::onZChanged( boost::ref(e) );
        }
    }
    
    virtual void default_onZChanged( ::CEGUI::WindowEventArgs & e ){
        CEGUI::Window::onZChanged( boost::ref(e) );
    }

    virtual void performChildWindowLayout( bool nonclient_sized_hint=false, bool client_sized_hint=false ) {
        if( bp::override func_performChildWindowLayout = this->get_override( "performChildWindowLayout" ) )
            func_performChildWindowLayout( nonclient_sized_hint, client_sized_hint );
        else{
            this->CEGUI::Window::performChildWindowLayout( nonclient_sized_hint, client_sized_hint );
        }
    }
    
    void default_performChildWindowLayout( bool nonclient_sized_hint=false, bool client_sized_hint=false ) {
        CEGUI::Window::performChildWindowLayout( nonclient_sized_hint, client_sized_hint );
    }

    virtual bool performCopy( ::CEGUI::Clipboard & clipboard ) {
        if( bp::override func_performCopy = this->get_override( "performCopy" ) )
            return func_performCopy( boost::ref(clipboard) );
        else{
            return this->CEGUI::Window::performCopy( boost::ref(clipboard) );
        }
    }
    
    bool default_performCopy( ::CEGUI::Clipboard & clipboard ) {
        return CEGUI::Window::performCopy( boost::ref(clipboard) );
    }

    virtual bool performCut( ::CEGUI::Clipboard & clipboard ) {
        if( bp::override func_performCut = this->get_override( "performCut" ) )
            return func_performCut( boost::ref(clipboard) );
        else{
            return this->CEGUI::Window::performCut( boost::ref(clipboard) );
        }
    }
    
    bool default_performCut( ::CEGUI::Clipboard & clipboard ) {
        return CEGUI::Window::performCut( boost::ref(clipboard) );
    }

    virtual bool performPaste( ::CEGUI::Clipboard & clipboard ) {
        if( bp::override func_performPaste = this->get_override( "performPaste" ) )
            return func_performPaste( boost::ref(clipboard) );
        else{
            return this->CEGUI::Window::performPaste( boost::ref(clipboard) );
        }
    }
    
    bool default_performPaste( ::CEGUI::Clipboard & clipboard ) {
        return CEGUI::Window::performPaste( boost::ref(clipboard) );
    }

    virtual void populateGeometryBuffer(  ){
        if( bp::override func_populateGeometryBuffer = this->get_override( "populateGeometryBuffer" ) )
            func_populateGeometryBuffer(  );
        else{
            this->CEGUI::Window::populateGeometryBuffer(  );
        }
    }
    
    virtual void default_populateGeometryBuffer(  ){
        CEGUI::Window::populateGeometryBuffer( );
    }

    void queueGeometry( ::CEGUI::RenderingContext const & ctx ){
        CEGUI::Window::queueGeometry( boost::ref(ctx) );
    }

    void releaseRenderingWindow(  ){
        CEGUI::Window::releaseRenderingWindow(  );
    }

    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::Window::removeChild_impl( boost::python::ptr(element) );
        }
    }
    
    virtual void default_removeChild_impl( ::CEGUI::Element * element ){
        CEGUI::Window::removeChild_impl( boost::python::ptr(element) );
    }

    void removeWindowFromDrawList( ::CEGUI::Window const & wnd ){
        CEGUI::Window::removeWindowFromDrawList( boost::ref(wnd) );
    }

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

    virtual void setParent( ::CEGUI::Element * parent ){
        if( bp::override func_setParent = this->get_override( "setParent" ) )
            func_setParent( boost::python::ptr(parent) );
        else{
            this->CEGUI::Window::setParent( boost::python::ptr(parent) );
        }
    }
    
    virtual void default_setParent( ::CEGUI::Element * parent ){
        CEGUI::Window::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 transferChildSurfaces(  ){
        CEGUI::Window::transferChildSurfaces(  );
    }

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

    void updateGeometryRenderSettings(  ){
        CEGUI::Window::updateGeometryRenderSettings(  );
    }

    virtual void updateSelf( float elapsed ){
        if( bp::override func_updateSelf = this->get_override( "updateSelf" ) )
            func_updateSelf( elapsed );
        else{
            this->CEGUI::Window::updateSelf( elapsed );
        }
    }
    
    virtual void default_updateSelf( float elapsed ){
        CEGUI::Window::updateSelf( elapsed );
    }

    virtual bool validateWindowRenderer( ::CEGUI::WindowRenderer const * renderer ) const {
        if( bp::override func_validateWindowRenderer = this->get_override( "validateWindowRenderer" ) )
            return func_validateWindowRenderer( boost::python::ptr(renderer) );
        else{
            return this->CEGUI::Window::validateWindowRenderer( boost::python::ptr(renderer) );
        }
    }
    
    virtual bool default_validateWindowRenderer( ::CEGUI::WindowRenderer const * renderer ) const {
        return CEGUI::Window::validateWindowRenderer( boost::python::ptr(renderer) );
    }

    virtual bool writeAutoChildWindowXML( ::CEGUI::XMLSerializer & xml_stream ) const {
        if( bp::override func_writeAutoChildWindowXML = this->get_override( "writeAutoChildWindowXML" ) )
            return func_writeAutoChildWindowXML( boost::ref(xml_stream) );
        else{
            return this->CEGUI::Window::writeAutoChildWindowXML( boost::ref(xml_stream) );
        }
    }
    
    virtual bool default_writeAutoChildWindowXML( ::CEGUI::XMLSerializer & xml_stream ) const {
        return CEGUI::Window::writeAutoChildWindowXML( boost::ref(xml_stream) );
    }

    virtual int writeChildWindowsXML( ::CEGUI::XMLSerializer & xml_stream ) const {
        if( bp::override func_writeChildWindowsXML = this->get_override( "writeChildWindowsXML" ) )
            return func_writeChildWindowsXML( boost::ref(xml_stream) );
        else{
            return this->CEGUI::Window::writeChildWindowsXML( boost::ref(xml_stream) );
        }
    }
    
    virtual int default_writeChildWindowsXML( ::CEGUI::XMLSerializer & xml_stream ) const {
        return CEGUI::Window::writeChildWindowsXML( boost::ref(xml_stream) );
    }

    virtual int writePropertiesXML( ::CEGUI::XMLSerializer & xml_stream ) const {
        if( bp::override func_writePropertiesXML = this->get_override( "writePropertiesXML" ) )
            return func_writePropertiesXML( boost::ref(xml_stream) );
        else{
            return this->CEGUI::Window::writePropertiesXML( boost::ref(xml_stream) );
        }
    }
    
    virtual int default_writePropertiesXML( ::CEGUI::XMLSerializer & xml_stream ) const {
        return CEGUI::Window::writePropertiesXML( boost::ref(xml_stream) );
    }

    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_Combobox_class(){

    { //::CEGUI::Combobox
        typedef bp::class_< Combobox_wrapper, bp::bases< CEGUI::Window >, boost::noncopyable > Combobox_exposer_t;
        Combobox_exposer_t Combobox_exposer = Combobox_exposer_t( "Combobox", "*!\n\
        \n\
           Base class for the Combobox widget\n\
        *\n", bp::init< CEGUI::String const &, CEGUI::String const & >(( bp::arg("type"), bp::arg("name") ), "*************************************************************************\n\
           Construction and Destruction\n\
        *************************************************************************\n\
        *!\n\
        \n\
           Constructor for Combobox base class\n\
        *\n") );
        bp::scope Combobox_scope( Combobox_exposer );
        { //::CEGUI::Combobox::activateEditbox
        
            typedef void ( ::CEGUI::Combobox::*activateEditbox_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "activateEditbox"
                , activateEditbox_function_type( &::CEGUI::Combobox::activateEditbox )
                , "*!\n\
               \n\
                  Activate the edit box component of the Combobox.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::addItem
        
            typedef void ( ::CEGUI::Combobox::*addItem_function_type )( ::CEGUI::ListboxItem * ) ;
            
            Combobox_exposer.def( 
                "addItem"
                , addItem_function_type( &::CEGUI::Combobox::addItem )
                , ( bp::arg("item") )
                , "*!\n\
               \n\
                  Add the given ListboxItem to the list.\n\
            \n\
               @param item\n\
                  Pointer to the ListboxItem to be added to the list.  Note that it is the passed object that is\
                  added to the\n\
                  list, a copy is not made.  If this parameter is NULL, nothing happens.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::button_PressHandler
        
            typedef bool ( Combobox_wrapper::*button_PressHandler_function_type )( ::CEGUI::EventArgs const & ) ;
            
            Combobox_exposer.def( 
                "button_PressHandler"
                , button_PressHandler_function_type( &Combobox_wrapper::button_PressHandler )
                , ( bp::arg("e") )
                , "*************************************************************************\n\
               Implementation Methods\n\
            *************************************************************************\n\
            *!\n\
            \n\
               Handler function for button clicks.\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::clearAllSelections
        
            typedef void ( ::CEGUI::Combobox::*clearAllSelections_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "clearAllSelections"
                , clearAllSelections_function_type( &::CEGUI::Combobox::clearAllSelections )
                , "*!\n\
               \n\
                  Clear the selected state for all items.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::droplist_HiddenHandler
        
            typedef bool ( Combobox_wrapper::*droplist_HiddenHandler_function_type )( ::CEGUI::EventArgs const & ) ;
            
            Combobox_exposer.def( 
                "droplist_HiddenHandler"
                , droplist_HiddenHandler_function_type( &Combobox_wrapper::droplist_HiddenHandler )
                , ( bp::arg("e") )
                , "*!\n\
            \n\
               Handler for when drop-list hides itself\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::droplist_SelectionAcceptedHandler
        
            typedef bool ( Combobox_wrapper::*droplist_SelectionAcceptedHandler_function_type )( ::CEGUI::EventArgs const & ) ;
            
            Combobox_exposer.def( 
                "droplist_SelectionAcceptedHandler"
                , droplist_SelectionAcceptedHandler_function_type( &Combobox_wrapper::droplist_SelectionAcceptedHandler )
                , ( bp::arg("e") )
                , "*!\n\
            \n\
               Handler for selections made in the drop-list\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::editbox_CaretMovedHandler
        
            typedef bool ( Combobox_wrapper::*editbox_CaretMovedHandler_function_type )( ::CEGUI::EventArgs const & ) ;
            
            Combobox_exposer.def( 
                "editbox_CaretMovedHandler"
                , editbox_CaretMovedHandler_function_type( &Combobox_wrapper::editbox_CaretMovedHandler )
                , ( bp::arg("e") ) );
        
        }
        { //::CEGUI::Combobox::editbox_EditboxFullEventHandler
        
            typedef bool ( Combobox_wrapper::*editbox_EditboxFullEventHandler_function_type )( ::CEGUI::EventArgs const & ) ;
            
            Combobox_exposer.def( 
                "editbox_EditboxFullEventHandler"
                , editbox_EditboxFullEventHandler_function_type( &Combobox_wrapper::editbox_EditboxFullEventHandler )
                , ( bp::arg("e") ) );
        
        }
        { //::CEGUI::Combobox::editbox_MaximumTextLengthChangedHandler
        
            typedef bool ( Combobox_wrapper::*editbox_MaximumTextLengthChangedHandler_function_type )( ::CEGUI::EventArgs const & ) ;
            
            Combobox_exposer.def( 
                "editbox_MaximumTextLengthChangedHandler"
                , editbox_MaximumTextLengthChangedHandler_function_type( &Combobox_wrapper::editbox_MaximumTextLengthChangedHandler )
                , ( bp::arg("e") ) );
        
        }
        { //::CEGUI::Combobox::editbox_MouseDownHandler
        
            typedef bool ( Combobox_wrapper::*editbox_MouseDownHandler_function_type )( ::CEGUI::EventArgs const & ) ;
            
            Combobox_exposer.def( 
                "editbox_MouseDownHandler"
                , editbox_MouseDownHandler_function_type( &Combobox_wrapper::editbox_MouseDownHandler )
                , ( bp::arg("e") )
                , "*!\n\
            \n\
               Mouse button down handler attached to edit box\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::editbox_ReadOnlyChangedHandler
        
            typedef bool ( Combobox_wrapper::*editbox_ReadOnlyChangedHandler_function_type )( ::CEGUI::EventArgs const & ) ;
            
            Combobox_exposer.def( 
                "editbox_ReadOnlyChangedHandler"
                , editbox_ReadOnlyChangedHandler_function_type( &Combobox_wrapper::editbox_ReadOnlyChangedHandler )
                , ( bp::arg("e") )
                , "*************************************************************************\n\
               Handlers to relay child widget events so they appear to come from us\n\
            *************************************************************************\n" );
        
        }
        { //::CEGUI::Combobox::editbox_TextAcceptedEventHandler
        
            typedef bool ( Combobox_wrapper::*editbox_TextAcceptedEventHandler_function_type )( ::CEGUI::EventArgs const & ) ;
            
            Combobox_exposer.def( 
                "editbox_TextAcceptedEventHandler"
                , editbox_TextAcceptedEventHandler_function_type( &Combobox_wrapper::editbox_TextAcceptedEventHandler )
                , ( bp::arg("e") ) );
        
        }
        { //::CEGUI::Combobox::editbox_TextChangedEventHandler
        
            typedef bool ( Combobox_wrapper::*editbox_TextChangedEventHandler_function_type )( ::CEGUI::EventArgs const & ) ;
            
            Combobox_exposer.def( 
                "editbox_TextChangedEventHandler"
                , editbox_TextChangedEventHandler_function_type( &Combobox_wrapper::editbox_TextChangedEventHandler )
                , ( bp::arg("e") ) );
        
        }
        { //::CEGUI::Combobox::editbox_TextSelectionChangedHandler
        
            typedef bool ( Combobox_wrapper::*editbox_TextSelectionChangedHandler_function_type )( ::CEGUI::EventArgs const & ) ;
            
            Combobox_exposer.def( 
                "editbox_TextSelectionChangedHandler"
                , editbox_TextSelectionChangedHandler_function_type( &Combobox_wrapper::editbox_TextSelectionChangedHandler )
                , ( bp::arg("e") ) );
        
        }
        { //::CEGUI::Combobox::editbox_TextValidityChangedHandler
        
            typedef bool ( Combobox_wrapper::*editbox_TextValidityChangedHandler_function_type )( ::CEGUI::EventArgs const & ) ;
            
            Combobox_exposer.def( 
                "editbox_TextValidityChangedHandler"
                , editbox_TextValidityChangedHandler_function_type( &Combobox_wrapper::editbox_TextValidityChangedHandler )
                , ( bp::arg("e") ) );
        
        }
        { //::CEGUI::Combobox::editbox_ValidationStringChangedHandler
        
            typedef bool ( Combobox_wrapper::*editbox_ValidationStringChangedHandler_function_type )( ::CEGUI::EventArgs const & ) ;
            
            Combobox_exposer.def( 
                "editbox_ValidationStringChangedHandler"
                , editbox_ValidationStringChangedHandler_function_type( &Combobox_wrapper::editbox_ValidationStringChangedHandler )
                , ( bp::arg("e") )
                , "*************************************************************************\n\
               Handlers to relay child widget events so they appear to come from us\n\
            *************************************************************************\n" );
        
        }
        { //::CEGUI::Combobox::findItemWithText
        
            typedef ::CEGUI::ListboxItem * ( ::CEGUI::Combobox::*findItemWithText_function_type )( ::CEGUI::String const &,::CEGUI::ListboxItem const * ) ;
            
            Combobox_exposer.def( 
                "findItemWithText"
                , findItemWithText_function_type( &::CEGUI::Combobox::findItemWithText )
                , ( bp::arg("text"), bp::arg("start_item") )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
               \n\
                  Search the list for an item with the specified text\n\
            \n\
               @param text\n\
                  String object containing the text to be searched for.\n\
            \n\
               @param start_item\n\
                  ListboxItem where the search is to begin, the search will not include  item.  If  item is\n\
                  NULL, the search will begin from the first item in the list.\n\
            \n\
               @return\n\
                  Pointer to the first ListboxItem in the list after  item that has text matching  text.  If\n\
                  no item matches the criteria NULL is returned.\n\
            \n\
               @exception  InvalidRequestException thrown if  item is not attached to this list box.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::getAutoSizeListHeightToContent
        
            typedef bool ( ::CEGUI::Combobox::*getAutoSizeListHeightToContent_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getAutoSizeListHeightToContent"
                , getAutoSizeListHeightToContent_function_type( &::CEGUI::Combobox::getAutoSizeListHeightToContent )
                , "! return whether the drop-list will vertically auto size to content.\n" );
        
        }
        { //::CEGUI::Combobox::getAutoSizeListWidthToContent
        
            typedef bool ( ::CEGUI::Combobox::*getAutoSizeListWidthToContent_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getAutoSizeListWidthToContent"
                , getAutoSizeListWidthToContent_function_type( &::CEGUI::Combobox::getAutoSizeListWidthToContent )
                , "! return whether the drop-list will horizontally auto size to content.\n" );
        
        }
        { //::CEGUI::Combobox::getCaretIndex
        
            typedef ::size_t ( ::CEGUI::Combobox::*getCaretIndex_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getCaretIndex"
                , getCaretIndex_function_type( &::CEGUI::Combobox::getCaretIndex )
                , "*!\n\
               \n\
                  return the current position of the caret.\n\
            \n\
               @return\n\
                  Index of the insert caret relative to the start of the text.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::getDropList
        
            typedef ::CEGUI::ComboDropList * ( ::CEGUI::Combobox::*getDropList_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getDropList"
                , getDropList_function_type( &::CEGUI::Combobox::getDropList )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
                \n\
                    Return a pointer to the ComboDropList component widget for this\n\
                    Combobox.\n\
            \n\
                @return\n\
                    Pointer to an ComboDropList object.\n\
            \n\
                @exception UnknownObjectException\n\
                    Thrown if the ComboDropList component does not exist.\n\
                *\n" );
        
        }
        { //::CEGUI::Combobox::getEditbox
        
            typedef ::CEGUI::Editbox * ( ::CEGUI::Combobox::*getEditbox_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getEditbox"
                , getEditbox_function_type( &::CEGUI::Combobox::getEditbox )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
                \n\
                    Return a pointer to the Editbox component widget for this Combobox.\n\
            \n\
                @return\n\
                    Pointer to an Editbox object.\n\
            \n\
                @exception UnknownObjectException\n\
                    Thrown if the Editbox component does not exist.\n\
                *\n" );
        
        }
        { //::CEGUI::Combobox::getItemCount
        
            typedef ::size_t ( ::CEGUI::Combobox::*getItemCount_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getItemCount"
                , getItemCount_function_type( &::CEGUI::Combobox::getItemCount )
                , "*************************************************************************\n\
                  List Accessors\n\
               *************************************************************************\n\
               *!\n\
               \n\
                  Return number of items attached to the list box\n\
            \n\
               @return\n\
                  the number of items currently attached to this list box.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::getItemIndex
        
            typedef ::size_t ( ::CEGUI::Combobox::*getItemIndex_function_type )( ::CEGUI::ListboxItem const * ) const;
            
            Combobox_exposer.def( 
                "getItemIndex"
                , getItemIndex_function_type( &::CEGUI::Combobox::getItemIndex )
                , ( bp::arg("item") )
                , "*!\n\
               \n\
                  Return the index of ListboxItem  item\n\
            \n\
               @param item\n\
                  Pointer to a ListboxItem whos zero based index is to be returned.\n\
            \n\
               @return\n\
                  Zero based index indicating the position of ListboxItem  item in the list box.\n\
            \n\
               @exception  InvalidRequestException thrown if  item is not attached to this list box.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::getListboxItemFromIndex
        
            typedef ::CEGUI::ListboxItem * ( ::CEGUI::Combobox::*getListboxItemFromIndex_function_type )( ::size_t ) const;
            
            Combobox_exposer.def( 
                "getListboxItemFromIndex"
                , getListboxItemFromIndex_function_type( &::CEGUI::Combobox::getListboxItemFromIndex )
                , ( bp::arg("index") )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
               \n\
                  Return the item at index position  index.\n\
            \n\
               @param index\n\
                  Zero based index of the item to be returned.\n\
            \n\
               @return\n\
                  Pointer to the ListboxItem at index position  index in the list box.\n\
            \n\
               @exception  InvalidRequestException thrown if  index is out of range.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::getMaxTextLength
        
            typedef ::size_t ( ::CEGUI::Combobox::*getMaxTextLength_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getMaxTextLength"
                , getMaxTextLength_function_type( &::CEGUI::Combobox::getMaxTextLength )
                , "*!\n\
               \n\
                  return the maximum text length set for this Editbox.\n\
            \n\
               @return\n\
                  The maximum number of code points (characters) that can be entered into this Editbox.\n\
            \n\
               \note\n\
                  Depending on the validation string set, the actual length of text that can be entered may be\
                  less than the value\n\
                  returned here (it will never be more).\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::getPushButton
        
            typedef ::CEGUI::PushButton * ( ::CEGUI::Combobox::*getPushButton_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getPushButton"
                , getPushButton_function_type( &::CEGUI::Combobox::getPushButton )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
                \n\
                    Return a pointer to the PushButton component widget for this Combobox.\n\
            \n\
                @return\n\
                    Pointer to a PushButton object.\n\
            \n\
                @exception UnknownObjectException\n\
                    Thrown if the PushButton component does not exist.\n\
                *\n" );
        
        }
        { //::CEGUI::Combobox::getSelectedItem
        
            typedef ::CEGUI::ListboxItem * ( ::CEGUI::Combobox::*getSelectedItem_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getSelectedItem"
                , getSelectedItem_function_type( &::CEGUI::Combobox::getSelectedItem )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
               \n\
                  Return a pointer to the currently selected item.\n\
            \n\
               @return\n\
                  Pointer to a ListboxItem based object that is the selected item in the list.  will return NULL\
                  if\n\
                  no item is selected.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::getSelectionEndIndex
        
            typedef ::size_t ( ::CEGUI::Combobox::*getSelectionEndIndex_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getSelectionEndIndex"
                , getSelectionEndIndex_function_type( &::CEGUI::Combobox::getSelectionEndIndex )
                , "*!\n\
               \n\
                  return the current selection end point.\n\
            \n\
               @return\n\
                  Index of the selection end point relative to the start of the text.  If no selection is\
                  defined this function returns\n\
                  the position of the caret.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::getSelectionLength
        
            typedef ::size_t ( ::CEGUI::Combobox::*getSelectionLength_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getSelectionLength"
                , getSelectionLength_function_type( &::CEGUI::Combobox::getSelectionLength )
                , "*!\n\
               \n\
                  return the length of the current selection (in code points  characters).\n\
            \n\
               @return\n\
                  Number of code points (or characters) contained within the currently defined selection.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::getSelectionStartIndex
        
            typedef ::size_t ( ::CEGUI::Combobox::*getSelectionStartIndex_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getSelectionStartIndex"
                , getSelectionStartIndex_function_type( &::CEGUI::Combobox::getSelectionStartIndex )
                , "*!\n\
               \n\
                  return the current selection start point.\n\
            \n\
               @return\n\
                  Index of the selection start point relative to the start of the text.  If no selection is\
                  defined this function returns\n\
                  the position of the caret.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::getSingleClickEnabled
        
            typedef bool ( ::CEGUI::Combobox::*getSingleClickEnabled_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getSingleClickEnabled"
                , getSingleClickEnabled_function_type( &::CEGUI::Combobox::getSingleClickEnabled )
                , "*!\n\
               \n\
                  returns the mode of operation for the combo box.\n\
            \n\
               @return\n\
                  - true if the user can show the list and select an item with a single mouse click.\n\
                  - false if the user must click to show the list and then click again to select an item.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::getTextMatchState
        
            typedef ::CEGUI::RegexMatcher::MatchState ( ::CEGUI::Combobox::*getTextMatchState_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getTextMatchState"
                , getTextMatchState_function_type( &::CEGUI::Combobox::getTextMatchState )
                , "*!\n\
                \n\
                    return the validation MatchState for the current Combobox text, given\n\
                    the currently set validation string.\n\
            \n\
                \note\n\
                    Validation is performed by means of a regular expression.  If the text\n\
                    matches the regex, the text is said to have passed validation.  If the\n\
                    text does not match with the regex then the text fails validation.\n\
            \n\
                @return\n\
                    One of the MatchState enumerated values indicating the current match\n\
                    state.\n\
                *\n" );
        
        }
        { //::CEGUI::Combobox::getValidationString
        
            typedef ::CEGUI::String const & ( ::CEGUI::Combobox::*getValidationString_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getValidationString"
                , getValidationString_function_type( &::CEGUI::Combobox::getValidationString )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "*!\n\
               \n\
                  return the currently set validation string\n\
            \n\
               \note\n\
                  Validation is performed by means of a regular expression.  If the text matches the regex, the\
                  text is said to have passed\n\
                  validation.  If the text does not match with the regex then the text fails validation.\n\
            \n\
               @return\n\
                  String object containing the current validation regex data\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::handleUpdatedListItemData
        
            typedef void ( ::CEGUI::Combobox::*handleUpdatedListItemData_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "handleUpdatedListItemData"
                , handleUpdatedListItemData_function_type( &::CEGUI::Combobox::handleUpdatedListItemData )
                , "*!\n\
               \n\
                  Causes the list box to update it's internal state after changes have been made to one or\
                  more\n\
                  attached ListboxItem objects.\n\
            \n\
                  Client code must call this whenever it has made any changes to ListboxItem objects already\
                  attached to the\n\
                  list box.  If you are just adding items, or removed items to update them prior to re-adding\
                  them, there is\n\
                  no need to call this method.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::hasInputFocus
        
            typedef bool ( ::CEGUI::Combobox::*hasInputFocus_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "hasInputFocus"
                , hasInputFocus_function_type( &::CEGUI::Combobox::hasInputFocus )
                , "*************************************************************************\n\
                  Editbox Accessors\n\
               *************************************************************************\n\
               *!\n\
               \n\
                  return true if the Editbox has input focus.\n\
            \n\
               @return\n\
                  true if the Editbox has keyboard input focus, false if the Editbox does not have keyboard\
                  input focus.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::hideDropList
        
            typedef void ( ::CEGUI::Combobox::*hideDropList_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "hideDropList"
                , hideDropList_function_type( &::CEGUI::Combobox::hideDropList )
                , "*!\n\
               \n\
                  Hide the drop-down list\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::initialiseComponents
        
            typedef void ( ::CEGUI::Combobox::*initialiseComponents_function_type )(  ) ;
            typedef void ( Combobox_wrapper::*default_initialiseComponents_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "initialiseComponents"
                , initialiseComponents_function_type(&::CEGUI::Combobox::initialiseComponents)
                , default_initialiseComponents_function_type(&Combobox_wrapper::default_initialiseComponents) );
        
        }
        { //::CEGUI::Combobox::insertItem
        
            typedef void ( ::CEGUI::Combobox::*insertItem_function_type )( ::CEGUI::ListboxItem *,::CEGUI::ListboxItem const * ) ;
            
            Combobox_exposer.def( 
                "insertItem"
                , insertItem_function_type( &::CEGUI::Combobox::insertItem )
                , ( bp::arg("item"), bp::arg("position") )
                , "*!\n\
               \n\
                  Insert an item into the list box after a specified item already in the list.\n\
            \n\
                  Note that if the list is sorted, the item may not end up in the requested position.\n\
            \n\
               @param item\n\
                  Pointer to the ListboxItem to be inserted.  Note that it is the passed object that is added to\
                  the\n\
                  list, a copy is not made.  If this parameter is NULL, nothing happens.\n\
            \n\
               @param position\n\
                  Pointer to a ListboxItem that  item is to be inserted after.  If this parameter is NULL, the\
                  item is\n\
                  inserted at the start of the list.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::isDropDownListVisible
        
            typedef bool ( ::CEGUI::Combobox::*isDropDownListVisible_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "isDropDownListVisible"
                , isDropDownListVisible_function_type( &::CEGUI::Combobox::isDropDownListVisible )
                , "*!\n\
               \n\
                  returns true if the drop down list is visible.\n\
            \n\
               @return\n\
                  true if the drop down list is visible, false otherwise.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::isHit
        
            typedef bool ( ::CEGUI::Combobox::*isHit_function_type )( ::CEGUI::Vector2f const &,bool const ) const;
            typedef bool ( Combobox_wrapper::*default_isHit_function_type )( ::CEGUI::Vector2f const &,bool const ) const;
            
            Combobox_exposer.def( 
                "isHit"
                , isHit_function_type(&::CEGUI::Combobox::isHit)
                , default_isHit_function_type(&Combobox_wrapper::default_isHit)
                , ( bp::arg("position"), bp::arg("allow_disabled")=(bool const)(false) ) );
        
        }
        { //::CEGUI::Combobox::isHorzScrollbarAlwaysShown
        
            typedef bool ( ::CEGUI::Combobox::*isHorzScrollbarAlwaysShown_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "isHorzScrollbarAlwaysShown"
                , isHorzScrollbarAlwaysShown_function_type( &::CEGUI::Combobox::isHorzScrollbarAlwaysShown )
                , "*!\n\
               \n\
                  Return whether the horizontal scroll bar is always shown.\n\
            \n\
               @return\n\
                  - true if the scroll bar will always 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::Combobox::isItemSelected
        
            typedef bool ( ::CEGUI::Combobox::*isItemSelected_function_type )( ::size_t ) const;
            
            Combobox_exposer.def( 
                "isItemSelected"
                , isItemSelected_function_type( &::CEGUI::Combobox::isItemSelected )
                , ( bp::arg("index") )
                , "*!\n\
               \n\
                  return whether the string at index position  index is selected\n\
            \n\
               @param index\n\
                  Zero based index of the item to be examined.\n\
            \n\
               @return\n\
                  true if the item at  index is selected, false if the item at  index is not selected.\n\
            \n\
               @exception  InvalidRequestException thrown if  index is out of range.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::isListboxItemInList
        
            typedef bool ( ::CEGUI::Combobox::*isListboxItemInList_function_type )( ::CEGUI::ListboxItem const * ) const;
            
            Combobox_exposer.def( 
                "isListboxItemInList"
                , isListboxItemInList_function_type( &::CEGUI::Combobox::isListboxItemInList )
                , ( bp::arg("item") )
                , "*!\n\
               \n\
                  Return whether the specified ListboxItem is in the List\n\
            \n\
               @return\n\
                  true if ListboxItem  item is in the list, false if ListboxItem  item is not in the list.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::isReadOnly
        
            typedef bool ( ::CEGUI::Combobox::*isReadOnly_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "isReadOnly"
                , isReadOnly_function_type( &::CEGUI::Combobox::isReadOnly )
                , "*!\n\
               \n\
                  return true if the Editbox is read-only.\n\
            \n\
               @return\n\
                  true if the Editbox is read only and can't be edited by the user, false if the Editbox is\
                  not\n\
                  read only and may be edited by the user.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::isSortEnabled
        
            typedef bool ( ::CEGUI::Combobox::*isSortEnabled_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "isSortEnabled"
                , isSortEnabled_function_type( &::CEGUI::Combobox::isSortEnabled )
                , "*!\n\
               \n\
                  return whether list sorting is enabled\n\
            \n\
               @return\n\
                  true if the list is sorted, false if the list is not sorted\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::isVertScrollbarAlwaysShown
        
            typedef bool ( ::CEGUI::Combobox::*isVertScrollbarAlwaysShown_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "isVertScrollbarAlwaysShown"
                , isVertScrollbarAlwaysShown_function_type( &::CEGUI::Combobox::isVertScrollbarAlwaysShown )
                , "*!\n\
               \n\
                  Return whether the vertical scroll bar is always shown.\n\
            \n\
               @return\n\
                  - true if the scroll bar will always 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::Combobox::itemSelectChangeTextUpdate
        
            typedef void ( Combobox_wrapper::*itemSelectChangeTextUpdate_function_type )( ::CEGUI::ListboxItem const * const,bool,bool ) ;
            
            Combobox_exposer.def( 
                "itemSelectChangeTextUpdate"
                , itemSelectChangeTextUpdate_function_type( &Combobox_wrapper::itemSelectChangeTextUpdate )
                , ( bp::arg("item"), bp::arg("new_state"), bp::arg("old_state") )
                , "*!\n\
            \n\
                Update the Combobox text to reflect programmatically made changes to\n\
                selected list item.\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::listbox_HorzScrollModeChangedHandler
        
            typedef bool ( Combobox_wrapper::*listbox_HorzScrollModeChangedHandler_function_type )( ::CEGUI::EventArgs const & ) ;
            
            Combobox_exposer.def( 
                "listbox_HorzScrollModeChangedHandler"
                , listbox_HorzScrollModeChangedHandler_function_type( &Combobox_wrapper::listbox_HorzScrollModeChangedHandler )
                , ( bp::arg("e") ) );
        
        }
        { //::CEGUI::Combobox::listbox_ListContentsChangedHandler
        
            typedef bool ( Combobox_wrapper::*listbox_ListContentsChangedHandler_function_type )( ::CEGUI::EventArgs const & ) ;
            
            Combobox_exposer.def( 
                "listbox_ListContentsChangedHandler"
                , listbox_ListContentsChangedHandler_function_type( &Combobox_wrapper::listbox_ListContentsChangedHandler )
                , ( bp::arg("e") ) );
        
        }
        { //::CEGUI::Combobox::listbox_ListSelectionChangedHandler
        
            typedef bool ( Combobox_wrapper::*listbox_ListSelectionChangedHandler_function_type )( ::CEGUI::EventArgs const & ) ;
            
            Combobox_exposer.def( 
                "listbox_ListSelectionChangedHandler"
                , listbox_ListSelectionChangedHandler_function_type( &Combobox_wrapper::listbox_ListSelectionChangedHandler )
                , ( bp::arg("e") ) );
        
        }
        { //::CEGUI::Combobox::listbox_SortModeChangedHandler
        
            typedef bool ( Combobox_wrapper::*listbox_SortModeChangedHandler_function_type )( ::CEGUI::EventArgs const & ) ;
            
            Combobox_exposer.def( 
                "listbox_SortModeChangedHandler"
                , listbox_SortModeChangedHandler_function_type( &Combobox_wrapper::listbox_SortModeChangedHandler )
                , ( bp::arg("e") ) );
        
        }
        { //::CEGUI::Combobox::listbox_VertScrollModeChangedHandler
        
            typedef bool ( Combobox_wrapper::*listbox_VertScrollModeChangedHandler_function_type )( ::CEGUI::EventArgs const & ) ;
            
            Combobox_exposer.def( 
                "listbox_VertScrollModeChangedHandler"
                , listbox_VertScrollModeChangedHandler_function_type( &Combobox_wrapper::listbox_VertScrollModeChangedHandler )
                , ( bp::arg("e") ) );
        
        }
        { //::CEGUI::Combobox::onActivated
        
            typedef void ( Combobox_wrapper::*onActivated_function_type )( ::CEGUI::ActivationEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onActivated"
                , onActivated_function_type( &Combobox_wrapper::default_onActivated )
                , ( bp::arg("e") ) );
        
        }
        { //::CEGUI::Combobox::onCaretMoved
        
            typedef void ( Combobox_wrapper::*onCaretMoved_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onCaretMoved"
                , onCaretMoved_function_type( &Combobox_wrapper::default_onCaretMoved )
                , ( bp::arg("e") )
                , "*!\n\
            \n\
               Handler called internally when the caret in the Comboxbox's Editbox moves.\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::onDropListDisplayed
        
            typedef void ( Combobox_wrapper::*onDropListDisplayed_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onDropListDisplayed"
                , onDropListDisplayed_function_type( &Combobox_wrapper::default_onDropListDisplayed )
                , ( bp::arg("e") )
                , "*!\n\
            \n\
               Handler called internally when the Combobox's drop-down list has been displayed.\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::onDroplistRemoved
        
            typedef void ( Combobox_wrapper::*onDroplistRemoved_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onDroplistRemoved"
                , onDroplistRemoved_function_type( &Combobox_wrapper::default_onDroplistRemoved )
                , ( bp::arg("e") )
                , "*!\n\
            \n\
               Handler called internally when the Combobox's drop-down list has been hidden.\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::onEditboxFullEvent
        
            typedef void ( Combobox_wrapper::*onEditboxFullEvent_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onEditboxFullEvent"
                , onEditboxFullEvent_function_type( &Combobox_wrapper::default_onEditboxFullEvent )
                , ( bp::arg("e") )
                , "*!\n\
            \n\
               Handler called internally when the maximum length is reached for text in the Combobox's\
               Editbox.\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::onFontChanged
        
            typedef void ( Combobox_wrapper::*onFontChanged_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onFontChanged"
                , onFontChanged_function_type( &Combobox_wrapper::default_onFontChanged )
                , ( bp::arg("e") )
                , "*************************************************************************\n\
               Overridden Event handlers\n\
            *************************************************************************\n" );
        
        }
        { //::CEGUI::Combobox::onHorzScrollbarModeChanged
        
            typedef void ( Combobox_wrapper::*onHorzScrollbarModeChanged_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onHorzScrollbarModeChanged"
                , onHorzScrollbarModeChanged_function_type( &Combobox_wrapper::default_onHorzScrollbarModeChanged )
                , ( bp::arg("e") )
                , "*!\n\
            \n\
               Handler called internally when the 'force' setting for the horizontal scrollbar within the\
               Combobox's\n\
               drop-down list is changed.\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::onListContentsChanged
        
            typedef void ( Combobox_wrapper::*onListContentsChanged_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onListContentsChanged"
                , onListContentsChanged_function_type( &Combobox_wrapper::default_onListContentsChanged )
                , ( bp::arg("e") )
                , "*!\n\
            \n\
               Handler called internally when the Combobox's Drop-down list contents are changed.\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::onListSelectionAccepted
        
            typedef void ( Combobox_wrapper::*onListSelectionAccepted_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onListSelectionAccepted"
                , onListSelectionAccepted_function_type( &Combobox_wrapper::default_onListSelectionAccepted )
                , ( bp::arg("e") )
                , "*!\n\
            \n\
               Handler called internally when the user has confirmed a selection within the Combobox's drop-down\
               list.\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::onListSelectionChanged
        
            typedef void ( Combobox_wrapper::*onListSelectionChanged_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onListSelectionChanged"
                , onListSelectionChanged_function_type( &Combobox_wrapper::default_onListSelectionChanged )
                , ( bp::arg("e") )
                , "*!\n\
            \n\
               Handler called internally when the selection within the Combobox's drop-down list changes\n\
               (this is not the 'final' accepted selection, just the currently highlighted item).\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::onMaximumTextLengthChanged
        
            typedef void ( Combobox_wrapper::*onMaximumTextLengthChanged_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onMaximumTextLengthChanged"
                , onMaximumTextLengthChanged_function_type( &Combobox_wrapper::default_onMaximumTextLengthChanged )
                , ( bp::arg("e") )
                , "*!\n\
            \n\
               Handler called internally when the Combobox's Editbox maximum text length is changed.\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::onReadOnlyChanged
        
            typedef void ( Combobox_wrapper::*onReadOnlyChanged_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onReadOnlyChanged"
                , onReadOnlyChanged_function_type( &Combobox_wrapper::default_onReadOnlyChanged )
                , ( bp::arg("e") )
                , "*************************************************************************\n\
               New Events for Combobox\n\
            *************************************************************************\n\
            *!\n\
            \n\
               Handler called internally when the read only state of the Combobox's Editbox has been changed.\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::onSized
        
            typedef void ( Combobox_wrapper::*onSized_function_type )( ::CEGUI::ElementEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onSized"
                , onSized_function_type( &Combobox_wrapper::default_onSized )
                , ( bp::arg("e") ) );
        
        }
        { //::CEGUI::Combobox::onSortModeChanged
        
            typedef void ( Combobox_wrapper::*onSortModeChanged_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onSortModeChanged"
                , onSortModeChanged_function_type( &Combobox_wrapper::default_onSortModeChanged )
                , ( bp::arg("e") )
                , "*!\n\
            \n\
               Handler called  fired internally when the sort mode for the Combobox's drop-down list is\
               changed.\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::onTextAcceptedEvent
        
            typedef void ( Combobox_wrapper::*onTextAcceptedEvent_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onTextAcceptedEvent"
                , onTextAcceptedEvent_function_type( &Combobox_wrapper::default_onTextAcceptedEvent )
                , ( bp::arg("e") )
                , "*!\n\
            \n\
               Handler called internally when the text in the Combobox's Editbox is accepted (by various\
               means).\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::onTextChanged
        
            typedef void ( Combobox_wrapper::*onTextChanged_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onTextChanged"
                , onTextChanged_function_type( &Combobox_wrapper::default_onTextChanged )
                , ( bp::arg("e") )
                , "*************************************************************************\n\
               Overridden Event handlers\n\
            *************************************************************************\n" );
        
        }
        { //::CEGUI::Combobox::onTextSelectionChanged
        
            typedef void ( Combobox_wrapper::*onTextSelectionChanged_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onTextSelectionChanged"
                , onTextSelectionChanged_function_type( &Combobox_wrapper::default_onTextSelectionChanged )
                , ( bp::arg("e") )
                , "*!\n\
            \n\
               Handler called internally when the selection within the Combobox's Editbox changes.\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::onTextValidityChanged
        
            typedef void ( Combobox_wrapper::*onTextValidityChanged_function_type )( ::CEGUI::RegexMatchStateEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onTextValidityChanged"
                , onTextValidityChanged_function_type( &Combobox_wrapper::default_onTextValidityChanged )
                , ( bp::arg("e") )
                , "*!\n\
            \n\
                Handler called when something has caused the validity state of the\n\
                current text to change.\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::onValidationStringChanged
        
            typedef void ( Combobox_wrapper::*onValidationStringChanged_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onValidationStringChanged"
                , onValidationStringChanged_function_type( &Combobox_wrapper::default_onValidationStringChanged )
                , ( bp::arg("e") )
                , "*!\n\
            \n\
               Handler called internally when the Combobox's Editbox validation string has been changed.\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::onVertScrollbarModeChanged
        
            typedef void ( Combobox_wrapper::*onVertScrollbarModeChanged_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onVertScrollbarModeChanged"
                , onVertScrollbarModeChanged_function_type( &Combobox_wrapper::default_onVertScrollbarModeChanged )
                , ( bp::arg("e") )
                , "*!\n\
            \n\
               Handler called internally when the 'force' setting for the vertical scrollbar within the\
               Combobox's\n\
               drop-down list is changed.\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::removeItem
        
            typedef void ( ::CEGUI::Combobox::*removeItem_function_type )( ::CEGUI::ListboxItem const * ) ;
            
            Combobox_exposer.def( 
                "removeItem"
                , removeItem_function_type( &::CEGUI::Combobox::removeItem )
                , ( bp::arg("item") )
                , "*!\n\
               \n\
                  Removes the given item from the list box.\n\
            \n\
               @param item\n\
                  Pointer to the ListboxItem that is to be removed.  If  item is not attached to this list box\
                  then nothing\n\
                  will happen.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::resetList
        
            typedef void ( ::CEGUI::Combobox::*resetList_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "resetList"
                , resetList_function_type( &::CEGUI::Combobox::resetList )
                , "*************************************************************************\n\
                  List Manipulators\n\
               *************************************************************************\n\
               *!\n\
               \n\
                  Remove all items from the list.\n\
            \n\
                  Note that this will cause 'AutoDelete' items to be deleted.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::selectListItemWithEditboxText
        
            typedef void ( ::CEGUI::Combobox::*selectListItemWithEditboxText_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "selectListItemWithEditboxText"
                , selectListItemWithEditboxText_function_type( &::CEGUI::Combobox::selectListItemWithEditboxText )
                , "! Select item in list matching editbox text, clear selection if none match\n" );
        
        }
        { //::CEGUI::Combobox::setAutoSizeListHeightToContent
        
            typedef void ( ::CEGUI::Combobox::*setAutoSizeListHeightToContent_function_type )( bool ) ;
            
            Combobox_exposer.def( 
                "setAutoSizeListHeightToContent"
                , setAutoSizeListHeightToContent_function_type( &::CEGUI::Combobox::setAutoSizeListHeightToContent )
                , ( bp::arg("auto_size") )
                , "*!\n\
            \n\
                Sets whether the Combobox drop-down list will automatically resize\n\
                it's height according to the total height of items added to the list.\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::setAutoSizeListWidthToContent
        
            typedef void ( ::CEGUI::Combobox::*setAutoSizeListWidthToContent_function_type )( bool ) ;
            
            Combobox_exposer.def( 
                "setAutoSizeListWidthToContent"
                , setAutoSizeListWidthToContent_function_type( &::CEGUI::Combobox::setAutoSizeListWidthToContent )
                , ( bp::arg("auto_size") )
                , "*!\n\
            \n\
                Sets whether the Combobox drop-down list will automatically resize\n\
                it's width according to the width of the items added to the list.\n\
            *\n" );
        
        }
        { //::CEGUI::Combobox::setCaretIndex
        
            typedef void ( ::CEGUI::Combobox::*setCaretIndex_function_type )( ::size_t ) ;
            
            Combobox_exposer.def( 
                "setCaretIndex"
                , setCaretIndex_function_type( &::CEGUI::Combobox::setCaretIndex )
                , ( bp::arg("caret_pos") )
                , "*!\n\
               \n\
                  Set the current position of the caret.\n\
            \n\
               @param caret_pos\n\
                  New index for the insert caret relative to the start of the text.  If the value specified is\
                  greater than the\n\
                  number of characters in the Editbox, the caret is positioned at the end of the text.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::setItemSelectState
        
            typedef void ( ::CEGUI::Combobox::*setItemSelectState_function_type )( ::CEGUI::ListboxItem *,bool ) ;
            
            Combobox_exposer.def( 
                "setItemSelectState"
                , setItemSelectState_function_type( &::CEGUI::Combobox::setItemSelectState )
                , ( bp::arg("item"), bp::arg("state") )
                , "*!\n\
               \n\
                  Set the select state of an attached ListboxItem.\n\
            \n\
                  This is the recommended way of selecting and deselecting items attached to a list box as it\
                  respects the\n\
                  multi-select mode setting.  It is possible to modify the setting on ListboxItems directly, but\
                  that approach\n\
                  does not respect the settings of the list box.\n\
            \n\
               @param item\n\
                  The ListboxItem to be affected.  This item must be attached to the list box.\n\
            \n\
               @param state\n\
                  true to select the item, false to de-select the item.\n\
            \n\
               @return\n\
                  Nothing.\n\
               \n\
               @exception  InvalidRequestException thrown if  item is not attached to this list box.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::setItemSelectState
        
            typedef void ( ::CEGUI::Combobox::*setItemSelectState_function_type )( ::size_t,bool ) ;
            
            Combobox_exposer.def( 
                "setItemSelectState"
                , setItemSelectState_function_type( &::CEGUI::Combobox::setItemSelectState )
                , ( bp::arg("item_index"), bp::arg("state") )
                , "*!\n\
               \n\
                  Set the select state of an attached ListboxItem.\n\
            \n\
                  This is the recommended way of selecting and deselecting items attached to a list box as it\
                  respects the\n\
                  multi-select mode setting.  It is possible to modify the setting on ListboxItems directly, but\
                  that approach\n\
                  does not respect the settings of the list box.\n\
            \n\
               @param item_index\n\
                  The zero based index of the ListboxItem to be affected.  This must be a valid index (0 <=\
                  index < getItemCount())\n\
            \n\
               @param state\n\
                  true to select the item, false to de-select the item.\n\
            \n\
               @return\n\
                  Nothing.\n\
               \n\
               @exception  InvalidRequestException thrown if  item_index is out of range for the list box\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::setMaxTextLength
        
            typedef void ( ::CEGUI::Combobox::*setMaxTextLength_function_type )( ::size_t ) ;
            
            Combobox_exposer.def( 
                "setMaxTextLength"
                , setMaxTextLength_function_type( &::CEGUI::Combobox::setMaxTextLength )
                , ( bp::arg("max_len") )
                , "*!\n\
               \n\
                  set the maximum text length for this Editbox.\n\
            \n\
               @param max_len\n\
                  The maximum number of code points (characters) that can be entered into this Editbox.\n\
            \n\
               \note\n\
                  Depending on the validation string set, the actual length of text that can be entered may be\
                  less than the value\n\
                  set here (it will never be more).\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::setReadOnly
        
            typedef void ( ::CEGUI::Combobox::*setReadOnly_function_type )( bool ) ;
            
            Combobox_exposer.def( 
                "setReadOnly"
                , setReadOnly_function_type( &::CEGUI::Combobox::setReadOnly )
                , ( bp::arg("setting") )
                , "*************************************************************************\n\
                  Editbox Manipulators\n\
               *************************************************************************\n\
               *!\n\
               \n\
                  Specify whether the Editbox is read-only.\n\
            \n\
               @param setting\n\
                  true if the Editbox is read only and can't be edited by the user, false if the Editbox is\
                  not\n\
                  read only and may be edited by the user.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::setSelection
        
            typedef void ( ::CEGUI::Combobox::*setSelection_function_type )( ::size_t,::size_t ) ;
            
            Combobox_exposer.def( 
                "setSelection"
                , setSelection_function_type( &::CEGUI::Combobox::setSelection )
                , ( bp::arg("start_pos"), bp::arg("end_pos") )
                , "*!\n\
               \n\
                  Define the current selection for the Editbox\n\
            \n\
               @param start_pos\n\
                  Index of the starting point for the selection.  If this value is greater than the number of\
                  characters in the Editbox, the\n\
                  selection start will be set to the end of the text.\n\
            \n\
               @param end_pos\n\
                  Index of the ending point for the selection.  If this value is greater than the number of\
                  characters in the Editbox, the\n\
                  selection start will be set to the end of the text.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::setSelectionLength
        
            typedef void ( ::CEGUI::Combobox::*setSelectionLength_function_type )( ::size_t ) ;
            
            Combobox_exposer.def( 
                "setSelectionLength"
                , setSelectionLength_function_type( &::CEGUI::Combobox::setSelectionLength )
                , ( bp::arg("length") )
                , "*!\n\
               \n\
                  Define the current selection for the Editbox\n\
            \n\
               @param start_pos\n\
                  Length of the selection.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::setSelectionStart
        
            typedef void ( ::CEGUI::Combobox::*setSelectionStart_function_type )( ::size_t ) ;
            
            Combobox_exposer.def( 
                "setSelectionStart"
                , setSelectionStart_function_type( &::CEGUI::Combobox::setSelectionStart )
                , ( bp::arg("start_pos") )
                , "*!\n\
               \n\
                  Define the current selection for the Editbox\n\
            \n\
               @param start_pos\n\
                  Index of the starting point for the selection.  If this value is greater than the number of\
                  characters in the Editbox, the\n\
                  selection start will be set to the end of the text.\n\
            \n\
               @param end_pos\n\
                  Index of the ending point for the selection.  If this value is greater than the number of\
                  characters in the Editbox, the\n\
                  selection start will be set to the end of the text.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n\
               *!\n\
               \n\
                  Define the current selection start for the Editbox\n\
            \n\
               @param start_pos\n\
                  Index of the starting point for the selection.  If this value is greater than the number of\
                  characters in the Editbox, the\n\
                  selection start will be set to the end of the text.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::setShowHorzScrollbar
        
            typedef void ( ::CEGUI::Combobox::*setShowHorzScrollbar_function_type )( bool ) ;
            
            Combobox_exposer.def( 
                "setShowHorzScrollbar"
                , setShowHorzScrollbar_function_type( &::CEGUI::Combobox::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 required.  false if the\
                  horizontal\n\
                  scroll bar should only be shown when it is required.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::setShowVertScrollbar
        
            typedef void ( ::CEGUI::Combobox::*setShowVertScrollbar_function_type )( bool ) ;
            
            Combobox_exposer.def( 
                "setShowVertScrollbar"
                , setShowVertScrollbar_function_type( &::CEGUI::Combobox::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 required.  false if the\
                  vertical\n\
                  scroll bar should only be shown when it is required.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::setSingleClickEnabled
        
            typedef void ( ::CEGUI::Combobox::*setSingleClickEnabled_function_type )( bool ) ;
            
            Combobox_exposer.def( 
                "setSingleClickEnabled"
                , setSingleClickEnabled_function_type( &::CEGUI::Combobox::setSingleClickEnabled )
                , ( bp::arg("setting") )
                , "*!\n\
               \n\
                  Set the mode of operation for the combo box.\n\
            \n\
               @param setting\n\
                  - true if the user should be able to show the list and select an item with a single mouse\
                  click.\n\
                  - false if the user must click to show the list and then click again to select an item.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::setSortingEnabled
        
            typedef void ( ::CEGUI::Combobox::*setSortingEnabled_function_type )( bool ) ;
            
            Combobox_exposer.def( 
                "setSortingEnabled"
                , setSortingEnabled_function_type( &::CEGUI::Combobox::setSortingEnabled )
                , ( bp::arg("setting") )
                , "*!\n\
               \n\
                  Set whether the list should be sorted.\n\
            \n\
               @param setting\n\
                  true if the list should be sorted, false if the list should not be sorted.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::setValidationString
        
            typedef void ( ::CEGUI::Combobox::*setValidationString_function_type )( ::CEGUI::String const & ) ;
            
            Combobox_exposer.def( 
                "setValidationString"
                , setValidationString_function_type( &::CEGUI::Combobox::setValidationString )
                , ( bp::arg("validation_string") )
                , "*!\n\
               \n\
                  Set the text validation string.\n\
            \n\
               \note\n\
                  Validation is performed by means of a regular expression.  If the text matches the regex, the\
                  text is said to have passed\n\
                  validation.  If the text does not match with the regex then the text fails validation.\n\
            \n\
               @param validation_string\n\
                  String object containing the validation regex data to be used.\n\
            \n\
               @return\n\
                  Nothing.\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::showDropList
        
            typedef void ( ::CEGUI::Combobox::*showDropList_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "showDropList"
                , showDropList_function_type( &::CEGUI::Combobox::showDropList )
                , "*!\n\
               \n\
                  Show the drop-down list\n\
            \n\
               @return\n\
                  Nothing\n\
               *\n" );
        
        }
        { //::CEGUI::Combobox::updateAutoSizedDropList
        
            typedef void ( ::CEGUI::Combobox::*updateAutoSizedDropList_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "updateAutoSizedDropList"
                , updateAutoSizedDropList_function_type( &::CEGUI::Combobox::updateAutoSizedDropList )
                , "! update drop list size according to auto-size options.\n" );
        
        }
        Combobox_exposer.add_static_property( "ButtonName"
                        , bp::make_getter( &CEGUI::Combobox::ButtonName
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Combobox_exposer.add_static_property( "DropListName"
                        , bp::make_getter( &CEGUI::Combobox::DropListName
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Combobox_exposer.add_static_property( "EditboxName"
                        , bp::make_getter( &CEGUI::Combobox::EditboxName
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Combobox_exposer.add_static_property( "EventCaretMoved"
                        , bp::make_getter( &CEGUI::Combobox::EventCaretMoved
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Combobox_exposer.add_static_property( "EventDropListDisplayed"
                        , bp::make_getter( &CEGUI::Combobox::EventDropListDisplayed
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Combobox_exposer.add_static_property( "EventDropListRemoved"
                        , bp::make_getter( &CEGUI::Combobox::EventDropListRemoved
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Combobox_exposer.add_static_property( "EventEditboxFull"
                        , bp::make_getter( &CEGUI::Combobox::EventEditboxFull
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Combobox_exposer.add_static_property( "EventHorzScrollbarModeChanged"
                        , bp::make_getter( &CEGUI::Combobox::EventHorzScrollbarModeChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Combobox_exposer.add_static_property( "EventListContentsChanged"
                        , bp::make_getter( &CEGUI::Combobox::EventListContentsChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Combobox_exposer.add_static_property( "EventListSelectionAccepted"
                        , bp::make_getter( &CEGUI::Combobox::EventListSelectionAccepted
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Combobox_exposer.add_static_property( "EventListSelectionChanged"
                        , bp::make_getter( &CEGUI::Combobox::EventListSelectionChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Combobox_exposer.add_static_property( "EventMaximumTextLengthChanged"
                        , bp::make_getter( &CEGUI::Combobox::EventMaximumTextLengthChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Combobox_exposer.add_static_property( "EventReadOnlyModeChanged"
                        , bp::make_getter( &CEGUI::Combobox::EventReadOnlyModeChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Combobox_exposer.add_static_property( "EventSortModeChanged"
                        , bp::make_getter( &CEGUI::Combobox::EventSortModeChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Combobox_exposer.add_static_property( "EventTextAccepted"
                        , bp::make_getter( &CEGUI::Combobox::EventTextAccepted
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Combobox_exposer.add_static_property( "EventTextSelectionChanged"
                        , bp::make_getter( &CEGUI::Combobox::EventTextSelectionChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Combobox_exposer.add_static_property( "EventTextValidityChanged"
                        , bp::make_getter( &CEGUI::Combobox::EventTextValidityChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Combobox_exposer.add_static_property( "EventValidationStringChanged"
                        , bp::make_getter( &CEGUI::Combobox::EventValidationStringChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Combobox_exposer.add_static_property( "EventVertScrollbarModeChanged"
                        , bp::make_getter( &CEGUI::Combobox::EventVertScrollbarModeChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        { //::CEGUI::Window::addChild_impl
        
            typedef void ( Combobox_wrapper::*addChild_impl_function_type )( ::CEGUI::Element * ) ;
            
            Combobox_exposer.def( 
                "addChild_impl"
                , addChild_impl_function_type( &Combobox_wrapper::default_addChild_impl )
                , ( bp::arg("element") )
                , "*!\n\
            opydoc Element.addChild_impl\n\
            *\n" );
        
        }
        { //::CEGUI::Element::addElementProperties
        
            typedef void ( Combobox_wrapper::*addElementProperties_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "addElementProperties"
                , addElementProperties_function_type( &Combobox_wrapper::addElementProperties )
                , "*!\n\
            \n\
                Add standard CEGUI.Element properties.\n\
            *\n" );
        
        }
        { //::CEGUI::NamedElement::addNamedElementProperties
        
            typedef void ( Combobox_wrapper::*addNamedElementProperties_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "addNamedElementProperties"
                , addNamedElementProperties_function_type( &Combobox_wrapper::addNamedElementProperties )
                , "*!\n\
             Add standard CEGUI.NamedElement properties.\n\
            *\n" );
        
        }
        { //::CEGUI::Window::addWindowProperties
        
            typedef void ( Combobox_wrapper::*addWindowProperties_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "addWindowProperties"
                , addWindowProperties_function_type( &Combobox_wrapper::addWindowProperties )
                , "*!\n\
            \n\
                Add standard CEGUI.Window properties.\n\
            *\n" );
        
        }
        { //::CEGUI::Window::addWindowToDrawList
        
            typedef void ( Combobox_wrapper::*addWindowToDrawList_function_type )( ::CEGUI::Window &,bool ) ;
            
            Combobox_exposer.def( 
                "addWindowToDrawList"
                , addWindowToDrawList_function_type( &Combobox_wrapper::addWindowToDrawList )
                , ( bp::arg("wnd"), bp::arg("at_back")=(bool)(false) )
                , "*!\n\
                \n\
                    Add the given window to the drawing list at an appropriate position for\n\
                    it's settings and the required direction.  Basically, when  at_back\n\
                    is false, the window will appear in front of all other windows with the\n\
                    same 'always on top' setting.  When  at_back is true, the window will\n\
                    appear behind all other windows wih the same 'always on top' setting.\n\
            \n\
                @param wnd\n\
                    Window object to be added to the drawing list.\n\
            \n\
                @param at_back\n\
                    Indicates whether the window should be placed at the back of other\n\
                    windows in the same group. If this is false, the window is placed in\n\
                    front of other windows in the group.\n\
            \n\
                @return\n\
                    Nothing.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::allocateRenderingWindow
        
            typedef void ( Combobox_wrapper::*allocateRenderingWindow_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "allocateRenderingWindow"
                , allocateRenderingWindow_function_type( &Combobox_wrapper::allocateRenderingWindow )
                , "! helper to create and setup the auto RenderingWindow surface\n" );
        
        }
        { //::CEGUI::Window::banPropertiesForAutoWindow
        
            typedef void ( Combobox_wrapper::*banPropertiesForAutoWindow_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "banPropertiesForAutoWindow"
                , banPropertiesForAutoWindow_function_type( &Combobox_wrapper::default_banPropertiesForAutoWindow ) );
        
        }
        { //::CEGUI::Window::beginInitialisation
        
            typedef void ( ::CEGUI::Window::*beginInitialisation_function_type )(  ) ;
            typedef void ( Combobox_wrapper::*default_beginInitialisation_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "beginInitialisation"
                , beginInitialisation_function_type(&::CEGUI::Window::beginInitialisation)
                , default_beginInitialisation_function_type(&Combobox_wrapper::default_beginInitialisation) );
        
        }
        { //::CEGUI::Window::bufferGeometry
        
            typedef void ( Combobox_wrapper::*bufferGeometry_function_type )( ::CEGUI::RenderingContext const & ) ;
            
            Combobox_exposer.def( 
                "bufferGeometry"
                , bufferGeometry_function_type( &Combobox_wrapper::bufferGeometry )
                , ( bp::arg("ctx") )
                , "*!\n\
                \n\
                    Perform drawing operations concerned with generating and buffering\n\
                    window geometry.\n\
            \n\
                \note\n\
                    This function is a sub-function of drawSelf; it is provided to make it\n\
                    easier to override drawSelf without needing to duplicate large sections\n\
                    of the code from the default implementation.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::cleanupChildren
        
            typedef void ( Combobox_wrapper::*cleanupChildren_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "cleanupChildren"
                , cleanupChildren_function_type( &Combobox_wrapper::default_cleanupChildren )
                , "*!\n\
            \n\
                Cleanup child windows\n\
            *\n" );
        
        }
        { //::CEGUI::Window::cloneChildWidgetsTo
        
            typedef void ( ::CEGUI::Window::*cloneChildWidgetsTo_function_type )( ::CEGUI::Window & ) const;
            typedef void ( Combobox_wrapper::*default_cloneChildWidgetsTo_function_type )( ::CEGUI::Window & ) const;
            
            Combobox_exposer.def( 
                "cloneChildWidgetsTo"
                , cloneChildWidgetsTo_function_type(&::CEGUI::Window::cloneChildWidgetsTo)
                , default_cloneChildWidgetsTo_function_type(&Combobox_wrapper::default_cloneChildWidgetsTo)
                , ( bp::arg("target") ) );
        
        }
        { //::CEGUI::Window::clonePropertiesTo
        
            typedef void ( ::CEGUI::Window::*clonePropertiesTo_function_type )( ::CEGUI::Window & ) const;
            typedef void ( Combobox_wrapper::*default_clonePropertiesTo_function_type )( ::CEGUI::Window & ) const;
            
            Combobox_exposer.def( 
                "clonePropertiesTo"
                , clonePropertiesTo_function_type(&::CEGUI::Window::clonePropertiesTo)
                , default_clonePropertiesTo_function_type(&Combobox_wrapper::default_clonePropertiesTo)
                , ( bp::arg("target") ) );
        
        }
        { //::CEGUI::Window::destroy
        
            typedef void ( ::CEGUI::Window::*destroy_function_type )(  ) ;
            typedef void ( Combobox_wrapper::*default_destroy_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "destroy"
                , destroy_function_type(&::CEGUI::Window::destroy)
                , default_destroy_function_type(&Combobox_wrapper::default_destroy) );
        
        }
        { //::CEGUI::Window::drawSelf
        
            typedef void ( Combobox_wrapper::*drawSelf_function_type )( ::CEGUI::RenderingContext const & ) ;
            
            Combobox_exposer.def( 
                "drawSelf"
                , drawSelf_function_type( &Combobox_wrapper::default_drawSelf )
                , ( bp::arg("ctx") )
                , "*!\n\
                \n\
                    Perform the actual rendering for this Window.\n\
            \n\
                @param ctx\n\
                    RenderingContext holding the details of the RenderingSurface to be\n\
                    used for the Window rendering operations.\n\
            \n\
                @return\n\
                    Nothing\n\
                *\n" );
        
        }
        { //::CEGUI::Window::endInitialisation
        
            typedef void ( ::CEGUI::Window::*endInitialisation_function_type )(  ) ;
            typedef void ( Combobox_wrapper::*default_endInitialisation_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "endInitialisation"
                , endInitialisation_function_type(&::CEGUI::Window::endInitialisation)
                , default_endInitialisation_function_type(&Combobox_wrapper::default_endInitialisation) );
        
        }
        { //::CEGUI::Element::fireAreaChangeEvents
        
            typedef void ( Combobox_wrapper::*fireAreaChangeEvents_function_type )( bool const,bool const ) ;
            
            Combobox_exposer.def( 
                "fireAreaChangeEvents"
                , fireAreaChangeEvents_function_type( &Combobox_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 ( Combobox_wrapper::*default_fireEvent_function_type )( ::CEGUI::String const &,::CEGUI::EventArgs &,::CEGUI::String const & ) ;
            
            Combobox_exposer.def( 
                "fireEvent"
                , fireEvent_function_type(&::CEGUI::EventSet::fireEvent)
                , default_fireEvent_function_type(&Combobox_wrapper::default_fireEvent)
                , ( bp::arg("name"), bp::arg("args"), bp::arg("eventNamespace")="" ) );
        
        }
        { //::CEGUI::EventSet::fireEvent_impl
        
            typedef void ( Combobox_wrapper::*fireEvent_impl_function_type )( ::CEGUI::String const &,::CEGUI::EventArgs & ) ;
            
            Combobox_exposer.def( 
                "fireEvent_impl"
                , fireEvent_impl_function_type( &Combobox_wrapper::fireEvent_impl )
                , ( bp::arg("name"), bp::arg("args") )
                , "! Implementation event firing member\n" );
        
        }
        { //::CEGUI::Window::generateAutoRepeatEvent
        
            typedef void ( Combobox_wrapper::*generateAutoRepeatEvent_function_type )( ::CEGUI::MouseButton ) ;
            
            Combobox_exposer.def( 
                "generateAutoRepeatEvent"
                , generateAutoRepeatEvent_function_type( &Combobox_wrapper::generateAutoRepeatEvent )
                , ( bp::arg("button") )
                , "*!\n\
            \n\
                Fires off a repeated mouse button down event for this window.\n\
            *\n" );
        
        }
        { //::CEGUI::NamedElement::getChildByNamePath_impl
        
            typedef ::CEGUI::NamedElement * ( Combobox_wrapper::*getChildByNamePath_impl_function_type )( ::CEGUI::String const & ) const;
            
            Combobox_exposer.def( 
                "getChildByNamePath_impl"
                , getChildByNamePath_impl_function_type( &Combobox_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 * ( Combobox_wrapper::*getChildByNameRecursive_impl_function_type )( ::CEGUI::String const & ) const;
            
            Combobox_exposer.def( 
                "getChildByNameRecursive_impl"
                , getChildByNameRecursive_impl_function_type( &Combobox_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::Element::getClientChildContentArea
        
            typedef ::CEGUI::Element::CachedRectf const & ( ::CEGUI::Element::*getClientChildContentArea_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getClientChildContentArea"
                , getClientChildContentArea_function_type(&::CEGUI::Element::getClientChildContentArea)
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::CEGUI::Window::getHitTestRect_impl
        
            typedef ::CEGUI::Rectf ( Combobox_wrapper::*getHitTestRect_impl_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getHitTestRect_impl"
                , getHitTestRect_impl_function_type( &Combobox_wrapper::default_getHitTestRect_impl )
                , "! Default implementation of function to return Window inner clipper area.\n\
            ! Default implementation of function to return Window hit-test area.\n" );
        
        }
        { //::CEGUI::Window::getInnerRectClipper_impl
        
            typedef ::CEGUI::Rectf ( Combobox_wrapper::*getInnerRectClipper_impl_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getInnerRectClipper_impl"
                , getInnerRectClipper_impl_function_type( &Combobox_wrapper::default_getInnerRectClipper_impl )
                , "! Default implementation of function to return Window outer clipper area.\n\
            ! Default implementation of function to return Window inner clipper area.\n" );
        
        }
        { //::CEGUI::Element::getNonClientChildContentArea
        
            typedef ::CEGUI::Element::CachedRectf const & ( ::CEGUI::Element::*getNonClientChildContentArea_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getNonClientChildContentArea"
                , getNonClientChildContentArea_function_type(&::CEGUI::Element::getNonClientChildContentArea)
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::CEGUI::Window::getOuterRectClipper_impl
        
            typedef ::CEGUI::Rectf ( Combobox_wrapper::*getOuterRectClipper_impl_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getOuterRectClipper_impl"
                , getOuterRectClipper_impl_function_type( &Combobox_wrapper::default_getOuterRectClipper_impl )
                , "! Default implementation of function to return Window outer clipper area.\n" );
        
        }
        { //::CEGUI::Window::getParentElementClipIntersection
        
            typedef ::CEGUI::Rectf ( Combobox_wrapper::*getParentElementClipIntersection_function_type )( ::CEGUI::Rectf const & ) const;
            
            Combobox_exposer.def( 
                "getParentElementClipIntersection"
                , getParentElementClipIntersection_function_type( &Combobox_wrapper::getParentElementClipIntersection )
                , ( bp::arg("unclipped_area") )
                , "! helper function for calculating clipping rectangles.\n" );
        
        }
        { //::CEGUI::Window::getRenderedStringParser
        
            typedef ::CEGUI::RenderedStringParser & ( ::CEGUI::Window::*getRenderedStringParser_function_type )(  ) const;
            
            Combobox_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 ( Combobox_wrapper::*default_getRenderingContext_impl_function_type )( ::CEGUI::RenderingContext & ) const;
            
            Combobox_exposer.def( 
                "getRenderingContext_impl"
                , getRenderingContext_impl_function_type(&::CEGUI::Window::getRenderingContext_impl)
                , default_getRenderingContext_impl_function_type(&Combobox_wrapper::default_getRenderingContext_impl)
                , ( bp::arg("ctx") ) );
        
        }
        { //::CEGUI::Window::getRootContainerSize
        
            typedef ::CEGUI::Sizef const & ( ::CEGUI::Window::*getRootContainerSize_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getRootContainerSize"
                , getRootContainerSize_function_type(&::CEGUI::Window::getRootContainerSize)
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::CEGUI::EventSet::getScriptModule
        
            typedef ::CEGUI::ScriptModule * ( Combobox_wrapper::*getScriptModule_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "getScriptModule"
                , getScriptModule_function_type( &Combobox_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::Window::getUnclippedInnerRect_impl
        
            typedef ::CEGUI::Rectf ( Combobox_wrapper::*getUnclippedInnerRect_impl_function_type )( bool ) const;
            
            Combobox_exposer.def( 
                "getUnclippedInnerRect_impl"
                , getUnclippedInnerRect_impl_function_type( &Combobox_wrapper::default_getUnclippedInnerRect_impl )
                , ( bp::arg("skipAllPixelAlignment") ) );
        
        }
        { //::CEGUI::Element::getUnclippedOuterRect_impl
        
            typedef ::CEGUI::Rectf ( Combobox_wrapper::*getUnclippedOuterRect_impl_function_type )( bool ) const;
            
            Combobox_exposer.def( 
                "getUnclippedOuterRect_impl"
                , getUnclippedOuterRect_impl_function_type( &Combobox_wrapper::default_getUnclippedOuterRect_impl )
                , ( bp::arg("skipAllPixelAlignment") )
                , "! Default implementation of function to return Element's outer rect area.\n" );
        
        }
        { //::CEGUI::Window::getWindowAttachedToCommonAncestor
        
            typedef ::CEGUI::Window const * ( Combobox_wrapper::*getWindowAttachedToCommonAncestor_function_type )( ::CEGUI::Window const & ) const;
            
            Combobox_exposer.def( 
                "getWindowAttachedToCommonAncestor"
                , getWindowAttachedToCommonAncestor_function_type( &Combobox_wrapper::getWindowAttachedToCommonAncestor )
                , ( bp::arg("wnd") )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
            \n\
                Helper function to return the ancestor Window of a wnd that is attached\n\
                as a child to a window that is also an ancestor of a this.  Returns 0\n\
                if a wnd and a this are not part of the same hierachy.\n\
             *\n" );
        
        }
        { //::CEGUI::Window::handleFontRenderSizeChange
        
            typedef bool ( Combobox_wrapper::*handleFontRenderSizeChange_function_type )( ::CEGUI::EventArgs const & ) ;
            
            Combobox_exposer.def( 
                "handleFontRenderSizeChange"
                , handleFontRenderSizeChange_function_type( &Combobox_wrapper::default_handleFontRenderSizeChange )
                , ( bp::arg("args") )
                , "! handler function for when font render size changes.\n" );
        
        }
        { //::CEGUI::Window::initialiseClippers
        
            typedef void ( Combobox_wrapper::*initialiseClippers_function_type )( ::CEGUI::RenderingContext const & ) ;
            
            Combobox_exposer.def( 
                "initialiseClippers"
                , initialiseClippers_function_type( &Combobox_wrapper::initialiseClippers )
                , ( bp::arg("ctx") )
                , "! Helper to intialise the needed clipping for geometry and render surface.\n" );
        
        }
        { //::CEGUI::Window::invalidate_impl
        
            typedef void ( Combobox_wrapper::*invalidate_impl_function_type )( bool const ) ;
            
            Combobox_exposer.def( 
                "invalidate_impl"
                , invalidate_impl_function_type( &Combobox_wrapper::invalidate_impl )
                , ( bp::arg("recursive") )
                , "! helper function to invalidate window and optionally child windows.\n" );
        
        }
        { //::CEGUI::Window::isHitTargetWindow
        
            typedef bool ( Combobox_wrapper::*isHitTargetWindow_function_type )( ::CEGUI::Vector2f const &,bool ) const;
            
            Combobox_exposer.def( 
                "isHitTargetWindow"
                , isHitTargetWindow_function_type( &Combobox_wrapper::isHitTargetWindow )
                , ( bp::arg("position"), bp::arg("allow_disabled") ) );
        
        }
        { //::CEGUI::Element::isInnerRectSizeChanged
        
            typedef bool ( Combobox_wrapper::*isInnerRectSizeChanged_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "isInnerRectSizeChanged"
                , isInnerRectSizeChanged_function_type( &Combobox_wrapper::isInnerRectSizeChanged )
                , "! helper to return whether the inner rect size has changed\n" );
        
        }
        { //::CEGUI::Window::isPropertyAtDefault
        
            typedef bool ( Combobox_wrapper::*isPropertyAtDefault_function_type )( ::CEGUI::Property const * ) const;
            
            Combobox_exposer.def( 
                "isPropertyAtDefault"
                , isPropertyAtDefault_function_type( &Combobox_wrapper::isPropertyAtDefault )
                , ( bp::arg("property") )
                , "*!\n\
            \n\
                Returns whether a property is at it's default value.\n\
                This function is different from Property.isDefatult as it takes the assigned look'n'feel\n\
                (if the is one) into account.\n\
            *\n" );
        
        }
        { //::CEGUI::Window::isTopOfZOrder
        
            typedef bool ( Combobox_wrapper::*isTopOfZOrder_function_type )(  ) const;
            
            Combobox_exposer.def( 
                "isTopOfZOrder"
                , isTopOfZOrder_function_type( &Combobox_wrapper::isTopOfZOrder )
                , "*!\n\
                \n\
                    Return whether the window is at the top of the Z-Order.  This will\n\
                    correctly take into account 'Always on top' windows as needed.\n\
            \n\
                @return\n\
                    - true if the Window is at the top of the z-order in relation to sibling\n\
                      windows with the same 'always on top' setting.\n\
                    - false if the Window is not at the top of the z-order in relation to\n\
                      sibling windows with the same 'always on top' setting.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::layoutLookNFeelChildWidgets
        
            typedef void ( Combobox_wrapper::*layoutLookNFeelChildWidgets_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "layoutLookNFeelChildWidgets"
                , layoutLookNFeelChildWidgets_function_type( &Combobox_wrapper::layoutLookNFeelChildWidgets )
                , "mark the rect caches defined on Window invalid (does not affect Element)\n" );
        
        }
        { //::CEGUI::Window::markCachedWindowRectsInvalid
        
            typedef void ( Combobox_wrapper::*markCachedWindowRectsInvalid_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "markCachedWindowRectsInvalid"
                , markCachedWindowRectsInvalid_function_type( &Combobox_wrapper::markCachedWindowRectsInvalid )
                , "mark the rect caches defined on Window invalid (does not affect Element)\n" );
        
        }
        { //::CEGUI::Window::moveToFront_impl
        
            typedef bool ( Combobox_wrapper::*moveToFront_impl_function_type )( bool ) ;
            
            Combobox_exposer.def( 
                "moveToFront_impl"
                , moveToFront_impl_function_type( &Combobox_wrapper::default_moveToFront_impl )
                , ( bp::arg("wasClicked") )
                , "*!\n\
                \n\
                    Implements move to front behavior.\n\
            \n\
                @return\n\
                    Should return true if some action was taken, or false if there was\n\
                    nothing to be done.\n\
                *\n" );
        
        }
        { //::CEGUI::Element::notifyChildrenOfSizeChange
        
            typedef void ( Combobox_wrapper::*notifyChildrenOfSizeChange_function_type )( bool const,bool const ) ;
            
            Combobox_exposer.def( 
                "notifyChildrenOfSizeChange"
                , notifyChildrenOfSizeChange_function_type( &Combobox_wrapper::notifyChildrenOfSizeChange )
                , ( bp::arg("non_client"), bp::arg("client") ) );
        
        }
        { //::CEGUI::Window::notifyClippingChanged
        
            typedef void ( Combobox_wrapper::*notifyClippingChanged_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "notifyClippingChanged"
                , notifyClippingChanged_function_type( &Combobox_wrapper::notifyClippingChanged )
                , "*!\n\
            \n\
                Recursively inform all children that the clipping has changed and screen rects\n\
                needs to be recached.\n\
            *\n" );
        
        }
        { //::CEGUI::Window::notifyScreenAreaChanged
        
            typedef void ( ::CEGUI::Window::*notifyScreenAreaChanged_function_type )( bool ) ;
            typedef void ( Combobox_wrapper::*default_notifyScreenAreaChanged_function_type )( bool ) ;
            
            Combobox_exposer.def( 
                "notifyScreenAreaChanged"
                , notifyScreenAreaChanged_function_type(&::CEGUI::Window::notifyScreenAreaChanged)
                , default_notifyScreenAreaChanged_function_type(&Combobox_wrapper::default_notifyScreenAreaChanged)
                , ( bp::arg("recursive")=(bool)(true) ) );
        
        }
        { //::CEGUI::Window::onAlphaChanged
        
            typedef void ( Combobox_wrapper::*onAlphaChanged_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onAlphaChanged"
                , onAlphaChanged_function_type( &Combobox_wrapper::default_onAlphaChanged )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the window's alpha blend value is changed.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set to the window\n\
                    that triggered the event.  For this event the trigger window is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onAlwaysOnTopChanged
        
            typedef void ( Combobox_wrapper::*onAlwaysOnTopChanged_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onAlwaysOnTopChanged"
                , onAlwaysOnTopChanged_function_type( &Combobox_wrapper::default_onAlwaysOnTopChanged )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the window's always-on-top setting is changed.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set to the window\n\
                    that triggered the event.  For this event the trigger window is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onCaptureGained
        
            typedef void ( Combobox_wrapper::*onCaptureGained_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onCaptureGained"
                , onCaptureGained_function_type( &Combobox_wrapper::default_onCaptureGained )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when this window gains capture of mouse inputs.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set to the window\n\
                    that triggered the event.  For this event the trigger window is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onCaptureLost
        
            typedef void ( Combobox_wrapper::*onCaptureLost_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onCaptureLost"
                , onCaptureLost_function_type( &Combobox_wrapper::default_onCaptureLost )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when this window loses capture of mouse inputs.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set to the window\n\
                    that triggered the event.  For this event the trigger window is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onCharacter
        
            typedef void ( Combobox_wrapper::*onCharacter_function_type )( ::CEGUI::KeyEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onCharacter"
                , onCharacter_function_type( &Combobox_wrapper::default_onCharacter )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when a character-key has been pressed while this window\n\
                    has input focus.\n\
            \n\
                @param e\n\
                    KeyEventArgs object whose 'codepoint' field is set to the Unicode code\n\
                    point (encoded as utf32) for the character typed, and whose 'sysKeys'\n\
                    field represents the combination of SystemKey that were active when the\n\
                    event was generated.  All other fields should be considered as 'junk'.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onChildAdded
        
            typedef void ( Combobox_wrapper::*onChildAdded_function_type )( ::CEGUI::ElementEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onChildAdded"
                , onChildAdded_function_type( &Combobox_wrapper::default_onChildAdded )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when a child window is added to this window.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set to the window\n\
                    that has been added.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onChildRemoved
        
            typedef void ( Combobox_wrapper::*onChildRemoved_function_type )( ::CEGUI::ElementEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onChildRemoved"
                , onChildRemoved_function_type( &Combobox_wrapper::default_onChildRemoved )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when a child window is removed from this window.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set the window\n\
                    that has been removed.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onClippingChanged
        
            typedef void ( Combobox_wrapper::*onClippingChanged_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onClippingChanged"
                , onClippingChanged_function_type( &Combobox_wrapper::default_onClippingChanged )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the window's setting for being clipped by it's\n\
                    parent is changed.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set to the window\n\
                    that triggered the event.  For this event the trigger window is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onDeactivated
        
            typedef void ( Combobox_wrapper::*onDeactivated_function_type )( ::CEGUI::ActivationEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onDeactivated"
                , onDeactivated_function_type( &Combobox_wrapper::default_onDeactivated )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when this window has lost input focus and has been\n\
                    deactivated.\n\
            \n\
                @param e\n\
                    ActivationEventArgs object whose 'otherWindow' field is set to the\n\
                    window that has now become active, or NULL for none.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onDestructionStarted
        
            typedef void ( Combobox_wrapper::*onDestructionStarted_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onDestructionStarted"
                , onDestructionStarted_function_type( &Combobox_wrapper::default_onDestructionStarted )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when this window's destruction sequence has begun.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set to the window\n\
                    that triggered the event.  For this event the trigger window is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onDisabled
        
            typedef void ( Combobox_wrapper::*onDisabled_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onDisabled"
                , onDisabled_function_type( &Combobox_wrapper::default_onDisabled )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the window is disabled.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set to the window\n\
                    that triggered the event.  For this event the trigger window is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onDragDropItemDropped
        
            typedef void ( Combobox_wrapper::*onDragDropItemDropped_function_type )( ::CEGUI::DragDropEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onDragDropItemDropped"
                , onDragDropItemDropped_function_type( &Combobox_wrapper::default_onDragDropItemDropped )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when a DragContainer is dragged over this window.\n\
            \n\
                @param e\n\
                    DragDropEventArgs object initialised as follows:\n\
                    - window field is normaly set to point to 'this' window.\n\
                    - dragDropItem is a pointer to a DragContainer window that triggered\n\
                      the event.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onDragDropItemEnters
        
            typedef void ( Combobox_wrapper::*onDragDropItemEnters_function_type )( ::CEGUI::DragDropEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onDragDropItemEnters"
                , onDragDropItemEnters_function_type( &Combobox_wrapper::default_onDragDropItemEnters )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when a DragContainer is dragged over this window.\n\
            \n\
                @param e\n\
                    DragDropEventArgs object initialised as follows:\n\
                    - window field is normaly set to point to 'this' window.\n\
                    - dragDropItem is a pointer to a DragContainer window that triggered\n\
                      the event.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onDragDropItemLeaves
        
            typedef void ( Combobox_wrapper::*onDragDropItemLeaves_function_type )( ::CEGUI::DragDropEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onDragDropItemLeaves"
                , onDragDropItemLeaves_function_type( &Combobox_wrapper::default_onDragDropItemLeaves )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when a DragContainer is dragged over this window.\n\
            \n\
                @param e\n\
                    DragDropEventArgs object initialised as follows:\n\
                    - window field is normaly set to point to 'this' window.\n\
                    - dragDropItem is a pointer to a DragContainer window that triggered\n\
                      the event.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onEnabled
        
            typedef void ( Combobox_wrapper::*onEnabled_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onEnabled"
                , onEnabled_function_type( &Combobox_wrapper::default_onEnabled )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the window is enabled.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set to the window\n\
                    that triggered the event.  For this event the trigger window is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onHidden
        
            typedef void ( Combobox_wrapper::*onHidden_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onHidden"
                , onHidden_function_type( &Combobox_wrapper::default_onHidden )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the window is hidden.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set to the window\n\
                    that triggered the event.  For this event the trigger window is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::Element::onHorizontalAlignmentChanged
        
            typedef void ( Combobox_wrapper::*onHorizontalAlignmentChanged_function_type )( ::CEGUI::ElementEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onHorizontalAlignmentChanged"
                , onHorizontalAlignmentChanged_function_type( &Combobox_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::Window::onIDChanged
        
            typedef void ( Combobox_wrapper::*onIDChanged_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onIDChanged"
                , onIDChanged_function_type( &Combobox_wrapper::default_onIDChanged )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the window's client assigned ID is changed.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set to the window\n\
                    that triggered the event.  For this event the trigger window is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onInheritsAlphaChanged
        
            typedef void ( Combobox_wrapper::*onInheritsAlphaChanged_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onInheritsAlphaChanged"
                , onInheritsAlphaChanged_function_type( &Combobox_wrapper::default_onInheritsAlphaChanged )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the window's setting for inheriting alpha-blending\n\
                    is changed.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set to the window\n\
                    that triggered the event.  For this event the trigger window is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onInvalidated
        
            typedef void ( Combobox_wrapper::*onInvalidated_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onInvalidated"
                , onInvalidated_function_type( &Combobox_wrapper::default_onInvalidated )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when this window gets invalidated.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set to the window\n\
                    that triggered the event.  For this event the trigger window is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onKeyDown
        
            typedef void ( Combobox_wrapper::*onKeyDown_function_type )( ::CEGUI::KeyEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onKeyDown"
                , onKeyDown_function_type( &Combobox_wrapper::default_onKeyDown )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when a key as been depressed while this window has input\n\
                    focus.\n\
            \n\
                @param e\n\
                    KeyEventArgs object whose 'scancode' field is set to the Key.Scan value\n\
                    representing the key that was pressed, and whose 'sysKeys' field\n\
                    represents the combination of SystemKey that were active when the event\n\
                    was generated.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onKeyUp
        
            typedef void ( Combobox_wrapper::*onKeyUp_function_type )( ::CEGUI::KeyEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onKeyUp"
                , onKeyUp_function_type( &Combobox_wrapper::default_onKeyUp )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when a key as been released while this window has input\n\
                    focus.\n\
            \n\
                @param e\n\
                    KeyEventArgs object whose 'scancode' field is set to the Key.Scan value\n\
                    representing the key that was released, and whose 'sysKeys' field\n\
                    represents the combination of SystemKey that were active when the event\n\
                    was generated.  All other fields should be considered as 'junk'.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onMarginChanged
        
            typedef void ( Combobox_wrapper::*onMarginChanged_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onMarginChanged"
                , onMarginChanged_function_type( &Combobox_wrapper::default_onMarginChanged )
                , ( bp::arg("e") ) );
        
        }
        { //::CEGUI::Window::onMouseButtonDown
        
            typedef void ( Combobox_wrapper::*onMouseButtonDown_function_type )( ::CEGUI::MouseEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onMouseButtonDown"
                , onMouseButtonDown_function_type( &Combobox_wrapper::default_onMouseButtonDown )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when a mouse button has been depressed within this\n\
                    window's area.\n\
            \n\
                @param e\n\
                    MouseEventArgs object.  All fields are valid.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onMouseButtonUp
        
            typedef void ( Combobox_wrapper::*onMouseButtonUp_function_type )( ::CEGUI::MouseEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onMouseButtonUp"
                , onMouseButtonUp_function_type( &Combobox_wrapper::default_onMouseButtonUp )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when a mouse button has been released within this\n\
                    window's area.\n\
            \n\
                @param e\n\
                    MouseEventArgs object.  All fields are valid.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onMouseClicked
        
            typedef void ( Combobox_wrapper::*onMouseClicked_function_type )( ::CEGUI::MouseEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onMouseClicked"
                , onMouseClicked_function_type( &Combobox_wrapper::default_onMouseClicked )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when a mouse button has been clicked (that is depressed\n\
                    and then released, within a specified time) within this window's area.\n\
            \n\
                @param e\n\
                    MouseEventArgs object.  All fields are valid.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onMouseDoubleClicked
        
            typedef void ( Combobox_wrapper::*onMouseDoubleClicked_function_type )( ::CEGUI::MouseEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onMouseDoubleClicked"
                , onMouseDoubleClicked_function_type( &Combobox_wrapper::default_onMouseDoubleClicked )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when a mouse button has been double-clicked within this\n\
                    window's area.\n\
            \n\
                @param e\n\
                    MouseEventArgs object.  All fields are valid.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onMouseEnters
        
            typedef void ( Combobox_wrapper::*onMouseEnters_function_type )( ::CEGUI::MouseEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onMouseEnters"
                , onMouseEnters_function_type( &Combobox_wrapper::default_onMouseEnters )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the mouse cursor has entered this window's area and\n\
                    is actually over some part of this windows surface and not, for\n\
                    instance over a child window - even though technically in those cases\n\
                    the mouse is also within this Window's area, the handler will not be\n\
                    called.\n\
            \n\
                @param e\n\
                    MouseEventArgs object.  All fields are valid.\n\
            \n\
                @see\n\
                    Window.onMouseEntersArea\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onMouseEntersArea
        
            typedef void ( Combobox_wrapper::*onMouseEntersArea_function_type )( ::CEGUI::MouseEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onMouseEntersArea"
                , onMouseEntersArea_function_type( &Combobox_wrapper::default_onMouseEntersArea )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the mouse cursor has entered this window's area.\n\
            \n\
                @param e\n\
                    MouseEventArgs object.  All fields are valid.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onMouseLeaves
        
            typedef void ( Combobox_wrapper::*onMouseLeaves_function_type )( ::CEGUI::MouseEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onMouseLeaves"
                , onMouseLeaves_function_type( &Combobox_wrapper::default_onMouseLeaves )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the mouse cursor is no longer over this window's\n\
                    surface area.  This will be called when the mouse is not over a part\n\
                    of this Window's actual surface - even though technically the mouse is\n\
                    still within the Window's area, for example if the mouse moves over a\n\
                    child window.\n\
            \n\
                @param e\n\
                    MouseEventArgs object.  All fields are valid.\n\
            \n\
                @see\n\
                    Window.onMouseLeavesArea\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onMouseLeavesArea
        
            typedef void ( Combobox_wrapper::*onMouseLeavesArea_function_type )( ::CEGUI::MouseEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onMouseLeavesArea"
                , onMouseLeavesArea_function_type( &Combobox_wrapper::default_onMouseLeavesArea )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the mouse cursor has left this window's area.\n\
            \n\
                @param e\n\
                    MouseEventArgs object.  All fields are valid.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onMouseMove
        
            typedef void ( Combobox_wrapper::*onMouseMove_function_type )( ::CEGUI::MouseEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onMouseMove"
                , onMouseMove_function_type( &Combobox_wrapper::default_onMouseMove )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the mouse cursor has been moved within this window's\n\
                    area.\n\
            \n\
                @param e\n\
                    MouseEventArgs object.  All fields are valid.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onMouseTripleClicked
        
            typedef void ( Combobox_wrapper::*onMouseTripleClicked_function_type )( ::CEGUI::MouseEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onMouseTripleClicked"
                , onMouseTripleClicked_function_type( &Combobox_wrapper::default_onMouseTripleClicked )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when a mouse button has been triple-clicked within this\n\
                    window's area.\n\
            \n\
                @param e\n\
                    MouseEventArgs object.  All fields are valid.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onMouseWheel
        
            typedef void ( Combobox_wrapper::*onMouseWheel_function_type )( ::CEGUI::MouseEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onMouseWheel"
                , onMouseWheel_function_type( &Combobox_wrapper::default_onMouseWheel )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the mouse wheel (z-axis) position changes within\n\
                    this window's area.\n\
            \n\
                @param e\n\
                    MouseEventArgs object.  All fields are valid.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onMoved
        
            typedef void ( Combobox_wrapper::*onMoved_function_type )( ::CEGUI::ElementEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onMoved"
                , onMoved_function_type( &Combobox_wrapper::default_onMoved )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the window's position changes.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set to the window\n\
                    that triggered the event.  For this event the trigger window is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::NamedElement::onNameChanged
        
            typedef void ( Combobox_wrapper::*onNameChanged_function_type )( ::CEGUI::NamedElementEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onNameChanged"
                , onNameChanged_function_type( &Combobox_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::Element::onNonClientChanged
        
            typedef void ( Combobox_wrapper::*onNonClientChanged_function_type )( ::CEGUI::ElementEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onNonClientChanged"
                , onNonClientChanged_function_type( &Combobox_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::Window::onParentDestroyChanged
        
            typedef void ( Combobox_wrapper::*onParentDestroyChanged_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onParentDestroyChanged"
                , onParentDestroyChanged_function_type( &Combobox_wrapper::default_onParentDestroyChanged )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the window's setting for being destroyed\n\
                    automatically be it's parent is changed.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set to the window\n\
                    that triggered the event.  For this event the trigger window is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onParentSized
        
            typedef void ( Combobox_wrapper::*onParentSized_function_type )( ::CEGUI::ElementEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onParentSized"
                , onParentSized_function_type( &Combobox_wrapper::default_onParentSized )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when this window's parent window has been resized.  If\n\
                    this window is the root  GUI Sheet window, this call will be made when\n\
                    the display size changes.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set the the\n\
                    window that caused the event; this is typically either this window's\n\
                    parent window, or NULL to indicate the screen size has changed.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onRenderingEnded
        
            typedef void ( Combobox_wrapper::*onRenderingEnded_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onRenderingEnded"
                , onRenderingEnded_function_type( &Combobox_wrapper::default_onRenderingEnded )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when rendering for this window has ended.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set to the window\n\
                    that triggered the event.  For this event the trigger window is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onRenderingStarted
        
            typedef void ( Combobox_wrapper::*onRenderingStarted_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onRenderingStarted"
                , onRenderingStarted_function_type( &Combobox_wrapper::default_onRenderingStarted )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when rendering for this window has started.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set to the window\n\
                    that triggered the event.  For this event the trigger window is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onRotated
        
            typedef void ( Combobox_wrapper::*onRotated_function_type )( ::CEGUI::ElementEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onRotated"
                , onRotated_function_type( &Combobox_wrapper::default_onRotated )
                , ( bp::arg("e") ) );
        
        }
        { //::CEGUI::Window::onShown
        
            typedef void ( Combobox_wrapper::*onShown_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onShown"
                , onShown_function_type( &Combobox_wrapper::default_onShown )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the window is shown (made visible).\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set to the window\n\
                    that triggered the event.  For this event the trigger window is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onTextParsingChanged
        
            typedef void ( Combobox_wrapper::*onTextParsingChanged_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onTextParsingChanged"
                , onTextParsingChanged_function_type( &Combobox_wrapper::default_onTextParsingChanged )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the window's setting for whether text parsing is\n\
                    enabled is changed.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set to the window\n\
                    that triggered the event.  For this event the trigger window is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::Element::onVerticalAlignmentChanged
        
            typedef void ( Combobox_wrapper::*onVerticalAlignmentChanged_function_type )( ::CEGUI::ElementEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onVerticalAlignmentChanged"
                , onVerticalAlignmentChanged_function_type( &Combobox_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::Window::onWindowRendererAttached
        
            typedef void ( Combobox_wrapper::*onWindowRendererAttached_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onWindowRendererAttached"
                , onWindowRendererAttached_function_type( &Combobox_wrapper::default_onWindowRendererAttached )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when a new window renderer object is attached.\n\
            \n\
                @param e\n\
                    WindowEventArgs object initialised as follows:\n\
                    - window field is set to point to the Window object that just got a new\n\
                      window renderer attached. (typically 'this').\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onWindowRendererDetached
        
            typedef void ( Combobox_wrapper::*onWindowRendererDetached_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onWindowRendererDetached"
                , onWindowRendererDetached_function_type( &Combobox_wrapper::default_onWindowRendererDetached )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the currently attached window renderer object is detached.\n\
            \n\
                @param e\n\
                    WindowEventArgs object initialised as follows:\n\
                    - window field is set to point to the Window object that just got lost its\n\
                      window renderer. (typically 'this').\n\
                *\n" );
        
        }
        { //::CEGUI::Window::onZChange_impl
        
            typedef void ( Combobox_wrapper::*onZChange_impl_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "onZChange_impl"
                , onZChange_impl_function_type( &Combobox_wrapper::default_onZChange_impl )
                , "*!\n\
            \n\
                Notify 'this' and all siblings of a ZOrder change event\n\
            *\n" );
        
        }
        { //::CEGUI::Window::onZChanged
        
            typedef void ( Combobox_wrapper::*onZChanged_function_type )( ::CEGUI::WindowEventArgs & ) ;
            
            Combobox_exposer.def( 
                "onZChanged"
                , onZChanged_function_type( &Combobox_wrapper::default_onZChanged )
                , ( bp::arg("e") )
                , "*!\n\
                \n\
                    Handler called when the z-order position of this window has changed.\n\
            \n\
                @param e\n\
                    WindowEventArgs object whose 'window' pointer field is set to the window\n\
                    that triggered the event.  For this event the trigger window is always\n\
                    'this'.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::performChildWindowLayout
        
            typedef void ( ::CEGUI::Window::*performChildWindowLayout_function_type )( bool,bool ) ;
            typedef void ( Combobox_wrapper::*default_performChildWindowLayout_function_type )( bool,bool ) ;
            
            Combobox_exposer.def( 
                "performChildWindowLayout"
                , performChildWindowLayout_function_type(&::CEGUI::Window::performChildWindowLayout)
                , default_performChildWindowLayout_function_type(&Combobox_wrapper::default_performChildWindowLayout)
                , ( bp::arg("nonclient_sized_hint")=(bool)(false), bp::arg("client_sized_hint")=(bool)(false) ) );
        
        }
        { //::CEGUI::Window::performCopy
        
            typedef bool ( ::CEGUI::Window::*performCopy_function_type )( ::CEGUI::Clipboard & ) ;
            typedef bool ( Combobox_wrapper::*default_performCopy_function_type )( ::CEGUI::Clipboard & ) ;
            
            Combobox_exposer.def( 
                "performCopy"
                , performCopy_function_type(&::CEGUI::Window::performCopy)
                , default_performCopy_function_type(&Combobox_wrapper::default_performCopy)
                , ( bp::arg("clipboard") ) );
        
        }
        { //::CEGUI::Window::performCut
        
            typedef bool ( ::CEGUI::Window::*performCut_function_type )( ::CEGUI::Clipboard & ) ;
            typedef bool ( Combobox_wrapper::*default_performCut_function_type )( ::CEGUI::Clipboard & ) ;
            
            Combobox_exposer.def( 
                "performCut"
                , performCut_function_type(&::CEGUI::Window::performCut)
                , default_performCut_function_type(&Combobox_wrapper::default_performCut)
                , ( bp::arg("clipboard") ) );
        
        }
        { //::CEGUI::Window::performPaste
        
            typedef bool ( ::CEGUI::Window::*performPaste_function_type )( ::CEGUI::Clipboard & ) ;
            typedef bool ( Combobox_wrapper::*default_performPaste_function_type )( ::CEGUI::Clipboard & ) ;
            
            Combobox_exposer.def( 
                "performPaste"
                , performPaste_function_type(&::CEGUI::Window::performPaste)
                , default_performPaste_function_type(&Combobox_wrapper::default_performPaste)
                , ( bp::arg("clipboard") ) );
        
        }
        { //::CEGUI::Window::populateGeometryBuffer
        
            typedef void ( Combobox_wrapper::*populateGeometryBuffer_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "populateGeometryBuffer"
                , populateGeometryBuffer_function_type( &Combobox_wrapper::default_populateGeometryBuffer )
                , "*!\n\
                \n\
                    Update the rendering cache.\n\
            \n\
                    Populates the Window's GeometryBuffer ready for rendering.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::queueGeometry
        
            typedef void ( Combobox_wrapper::*queueGeometry_function_type )( ::CEGUI::RenderingContext const & ) ;
            
            Combobox_exposer.def( 
                "queueGeometry"
                , queueGeometry_function_type( &Combobox_wrapper::queueGeometry )
                , ( bp::arg("ctx") )
                , "*!\n\
                \n\
                    Perform drawing operations concerned with positioning, clipping and\n\
                    queueing of window geometry to RenderingSurfaces.\n\
            \n\
                \note\n\
                    This function is a sub-function of drawSelf and is provided to make it\n\
                    easier to override drawSelf without needing to duplicate large sections\n\
                    of the code from the default implementation.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::releaseRenderingWindow
        
            typedef void ( Combobox_wrapper::*releaseRenderingWindow_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "releaseRenderingWindow"
                , releaseRenderingWindow_function_type( &Combobox_wrapper::releaseRenderingWindow )
                , "! helper to clean up the auto RenderingWindow surface\n" );
        
        }
        { //::CEGUI::Window::removeChild_impl
        
            typedef void ( Combobox_wrapper::*removeChild_impl_function_type )( ::CEGUI::Element * ) ;
            
            Combobox_exposer.def( 
                "removeChild_impl"
                , removeChild_impl_function_type( &Combobox_wrapper::default_removeChild_impl )
                , ( bp::arg("element") )
                , "*!\n\
            opydoc Element.removeChild_impl\n\
            *\n" );
        
        }
        { //::CEGUI::Window::removeWindowFromDrawList
        
            typedef void ( Combobox_wrapper::*removeWindowFromDrawList_function_type )( ::CEGUI::Window const & ) ;
            
            Combobox_exposer.def( 
                "removeWindowFromDrawList"
                , removeWindowFromDrawList_function_type( &Combobox_wrapper::removeWindowFromDrawList )
                , ( bp::arg("wnd") )
                , "*!\n\
                \n\
                    Removes the window from the drawing list.  If the window is not attached\n\
                    to the drawing list then nothing happens.\n\
            \n\
                @param wnd\n\
                    Window object to be removed from the drawing list.\n\
            \n\
                @return\n\
                    Nothing.\n\
                *\n" );
        
        }
        { //::CEGUI::Element::setArea
        
            typedef void ( ::CEGUI::Element::*setArea_function_type )( ::CEGUI::UVector2 const &,::CEGUI::USize const & ) ;
            typedef void ( Combobox_wrapper::*default_setArea_function_type )( ::CEGUI::UVector2 const &,::CEGUI::USize const & ) ;
            
            Combobox_exposer.def( 
                "setArea"
                , setArea_function_type(&::CEGUI::Element::setArea)
                , default_setArea_function_type(&Combobox_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 & ) ;
            
            Combobox_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 & ) ;
            
            Combobox_exposer.def( 
                "setArea"
                , setArea_function_type( &::CEGUI::Element::setArea )
                , ( bp::arg("area") )
                , "!  overload\n" );
        
        }
        { //::CEGUI::Window::setArea_impl
        
            typedef void ( Combobox_wrapper::*setArea_impl_function_type )( ::CEGUI::UVector2 const &,::CEGUI::USize const &,bool,bool ) ;
            
            Combobox_exposer.def( 
                "setArea_impl"
                , setArea_impl_function_type( &Combobox_wrapper::default_setArea_impl )
                , ( bp::arg("pos"), bp::arg("size"), bp::arg("topLeftSizing")=(bool)(false), bp::arg("fireEvents")=(bool)(true) )
                , "! opydoc Element.setArea_impl\n" );
        
        }
        { //::CEGUI::Element::setHorizontalAlignment
        
            typedef void ( ::CEGUI::Element::*setHorizontalAlignment_function_type )( ::CEGUI::HorizontalAlignment const ) ;
            typedef void ( Combobox_wrapper::*default_setHorizontalAlignment_function_type )( ::CEGUI::HorizontalAlignment const ) ;
            
            Combobox_exposer.def( 
                "setHorizontalAlignment"
                , setHorizontalAlignment_function_type(&::CEGUI::Element::setHorizontalAlignment)
                , default_setHorizontalAlignment_function_type(&Combobox_wrapper::default_setHorizontalAlignment)
                , ( bp::arg("alignment") ) );
        
        }
        { //::CEGUI::Window::setLookNFeel
        
            typedef void ( ::CEGUI::Window::*setLookNFeel_function_type )( ::CEGUI::String const & ) ;
            typedef void ( Combobox_wrapper::*default_setLookNFeel_function_type )( ::CEGUI::String const & ) ;
            
            Combobox_exposer.def( 
                "setLookNFeel"
                , setLookNFeel_function_type(&::CEGUI::Window::setLookNFeel)
                , default_setLookNFeel_function_type(&Combobox_wrapper::default_setLookNFeel)
                , ( bp::arg("look") ) );
        
        }
        { //::CEGUI::Window::setMargin
        
            typedef void ( ::CEGUI::Window::*setMargin_function_type )( ::CEGUI::UBox const & ) ;
            typedef void ( Combobox_wrapper::*default_setMargin_function_type )( ::CEGUI::UBox const & ) ;
            
            Combobox_exposer.def( 
                "setMargin"
                , setMargin_function_type(&::CEGUI::Window::setMargin)
                , default_setMargin_function_type(&Combobox_wrapper::default_setMargin)
                , ( bp::arg("margin") ) );
        
        }
        { //::CEGUI::NamedElement::setName
        
            typedef void ( ::CEGUI::NamedElement::*setName_function_type )( ::CEGUI::String const & ) ;
            typedef void ( Combobox_wrapper::*default_setName_function_type )( ::CEGUI::String const & ) ;
            
            Combobox_exposer.def( 
                "setName"
                , setName_function_type(&::CEGUI::NamedElement::setName)
                , default_setName_function_type(&Combobox_wrapper::default_setName)
                , ( bp::arg("name") ) );
        
        }
        { //::CEGUI::Window::setParent
        
            typedef void ( Combobox_wrapper::*setParent_function_type )( ::CEGUI::Element * ) ;
            
            Combobox_exposer.def( 
                "setParent"
                , setParent_function_type( &Combobox_wrapper::default_setParent )
                , ( bp::arg("parent") )
                , "*!\n\
                \n\
                    Set the parent window for this window object.\n\
            \n\
                @param parent\n\
                    Pointer to a Window object that is to be assigned as the parent to this\n\
                    Window.\n\
            \n\
                @return\n\
                    Nothing\n\
                *\n" );
        
        }
        { //::CEGUI::Element::setVerticalAlignment
        
            typedef void ( ::CEGUI::Element::*setVerticalAlignment_function_type )( ::CEGUI::VerticalAlignment const ) ;
            typedef void ( Combobox_wrapper::*default_setVerticalAlignment_function_type )( ::CEGUI::VerticalAlignment const ) ;
            
            Combobox_exposer.def( 
                "setVerticalAlignment"
                , setVerticalAlignment_function_type(&::CEGUI::Element::setVerticalAlignment)
                , default_setVerticalAlignment_function_type(&Combobox_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 > ( Combobox_wrapper::*default_subscribeScriptedEvent_function_type )( ::CEGUI::String const &,::CEGUI::String const & ) ;
            
            Combobox_exposer.def( 
                "subscribeScriptedEvent"
                , subscribeScriptedEvent_function_type(&::CEGUI::EventSet::subscribeScriptedEvent)
                , default_subscribeScriptedEvent_function_type(&Combobox_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 > ( Combobox_wrapper::*default_subscribeScriptedEvent_function_type )( ::CEGUI::String const &,unsigned int,::CEGUI::String const & ) ;
            
            Combobox_exposer.def( 
                "subscribeScriptedEvent"
                , subscribeScriptedEvent_function_type(&::CEGUI::EventSet::subscribeScriptedEvent)
                , default_subscribeScriptedEvent_function_type(&Combobox_wrapper::default_subscribeScriptedEvent)
                , ( bp::arg("name"), bp::arg("group"), bp::arg("subscriber_name") ) );
        
        }
        { //::CEGUI::Window::transferChildSurfaces
        
            typedef void ( Combobox_wrapper::*transferChildSurfaces_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "transferChildSurfaces"
                , transferChildSurfaces_function_type( &Combobox_wrapper::transferChildSurfaces )
                , "! transfer RenderingSurfaces to be owned by our target RenderingSurface.\n" );
        
        }
        { //::CEGUI::Window::update
        
            typedef void ( ::CEGUI::Window::*update_function_type )( float ) ;
            typedef void ( Combobox_wrapper::*default_update_function_type )( float ) ;
            
            Combobox_exposer.def( 
                "update"
                , update_function_type(&::CEGUI::Window::update)
                , default_update_function_type(&Combobox_wrapper::default_update)
                , ( bp::arg("elapsed") ) );
        
        }
        { //::CEGUI::Window::updateGeometryRenderSettings
        
            typedef void ( Combobox_wrapper::*updateGeometryRenderSettings_function_type )(  ) ;
            
            Combobox_exposer.def( 
                "updateGeometryRenderSettings"
                , updateGeometryRenderSettings_function_type( &Combobox_wrapper::updateGeometryRenderSettings )
                , "*!\n\
            \n\
                Update position and clip region on this Windows geometry  rendering\n\
                surface.\n\
            *\n" );
        
        }
        { //::CEGUI::Window::updateSelf
        
            typedef void ( Combobox_wrapper::*updateSelf_function_type )( float ) ;
            
            Combobox_exposer.def( 
                "updateSelf"
                , updateSelf_function_type( &Combobox_wrapper::default_updateSelf )
                , ( bp::arg("elapsed") )
                , "*************************************************************************\n\
                    Implementation Functions\n\
                *************************************************************************\n\
                *!\n\
                \n\
                    Perform actual update processing for this Window.\n\
            \n\
                @param elapsed\n\
                    float value indicating the number of seconds elapsed since the last\n\
                    update call.\n\
            \n\
                @return\n\
                    Nothing.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::validateWindowRenderer
        
            typedef bool ( Combobox_wrapper::*validateWindowRenderer_function_type )( ::CEGUI::WindowRenderer const * ) const;
            
            Combobox_exposer.def( 
                "validateWindowRenderer"
                , validateWindowRenderer_function_type( &Combobox_wrapper::default_validateWindowRenderer )
                , ( bp::arg("renderer") )
                , "*!\n\
                \n\
                    Function used in checking if a WindowRenderer is valid for this window.\n\
            \n\
                @param renderer\n\
                  Window renderer that will be checked (it can be null!)\n\
            \n\
                @return\n\
                    Returns true if the given WindowRenderer class name is valid for this window.\n\
                    False if not.\n\
                *\n" );
        
        }
        { //::CEGUI::Window::writeAutoChildWindowXML
        
            typedef bool ( Combobox_wrapper::*writeAutoChildWindowXML_function_type )( ::CEGUI::XMLSerializer & ) const;
            
            Combobox_exposer.def( 
                "writeAutoChildWindowXML"
                , writeAutoChildWindowXML_function_type( &Combobox_wrapper::default_writeAutoChildWindowXML )
                , ( bp::arg("xml_stream") ) );
        
        }
        { //::CEGUI::Window::writeChildWindowsXML
        
            typedef int ( Combobox_wrapper::*writeChildWindowsXML_function_type )( ::CEGUI::XMLSerializer & ) const;
            
            Combobox_exposer.def( 
                "writeChildWindowsXML"
                , writeChildWindowsXML_function_type( &Combobox_wrapper::default_writeChildWindowsXML )
                , ( bp::arg("xml_stream") ) );
        
        }
        { //::CEGUI::Window::writePropertiesXML
        
            typedef int ( Combobox_wrapper::*writePropertiesXML_function_type )( ::CEGUI::XMLSerializer & ) const;
            
            Combobox_exposer.def( 
                "writePropertiesXML"
                , writePropertiesXML_function_type( &Combobox_wrapper::default_writePropertiesXML )
                , ( bp::arg("xml_stream") ) );
        
        }
        { //::CEGUI::Window::writeXMLToStream
        
            typedef void ( ::CEGUI::Window::*writeXMLToStream_function_type )( ::CEGUI::XMLSerializer & ) const;
            typedef void ( Combobox_wrapper::*default_writeXMLToStream_function_type )( ::CEGUI::XMLSerializer & ) const;
            
            Combobox_exposer.def( 
                "writeXMLToStream"
                , writeXMLToStream_function_type(&::CEGUI::Window::writeXMLToStream)
                , default_writeXMLToStream_function_type(&Combobox_wrapper::default_writeXMLToStream)
                , ( bp::arg("xml_stream") ) );
        
        }
    }

}
