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

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

namespace bp = boost::python;

struct Tooltip_wrapper : CEGUI::Tooltip, bp::wrapper< CEGUI::Tooltip > {

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

    virtual ::CEGUI::Size getTextSize_impl(  ) const  {
        if( bp::override func_getTextSize_impl = this->get_override( "getTextSize_impl" ) )
            return func_getTextSize_impl(  );
        else{
            return this->CEGUI::Tooltip::getTextSize_impl(  );
        }
    }
    
    ::CEGUI::Size default_getTextSize_impl(  ) const  {
        return CEGUI::Tooltip::getTextSize_impl( );
    }

    virtual void beginInitialisation(  ) {
        if( bp::override func_beginInitialisation = this->get_override( "beginInitialisation" ) )
            func_beginInitialisation(  );
        else{
            this->CEGUI::Window::beginInitialisation(  );
        }
    }
    
    void default_beginInitialisation(  ) {
        CEGUI::Window::beginInitialisation( );
    }

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

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

    virtual void 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 endInitialisation(  ) {
        if( bp::override func_endInitialisation = this->get_override( "endInitialisation" ) )
            func_endInitialisation(  );
        else{
            this->CEGUI::Window::endInitialisation(  );
        }
    }
    
    void default_endInitialisation(  ) {
        CEGUI::Window::endInitialisation( );
    }

    virtual void fireEvent( ::CEGUI::String const & name, ::CEGUI::EventArgs & args, ::CEGUI::String const & eventNamespace="" ) {
        if( bp::override func_fireEvent = this->get_override( "fireEvent" ) )
            func_fireEvent( boost::ref(name), boost::ref(args), boost::ref(eventNamespace) );
        else{
            this->CEGUI::EventSet::fireEvent( boost::ref(name), boost::ref(args), boost::ref(eventNamespace) );
        }
    }
    
    void default_fireEvent( ::CEGUI::String const & name, ::CEGUI::EventArgs & args, ::CEGUI::String const & eventNamespace="" ) {
        CEGUI::EventSet::fireEvent( boost::ref(name), boost::ref(args), boost::ref(eventNamespace) );
    }

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

    virtual ::CEGUI::Rect getUnclippedInnerRect_impl(  ) const  {
        if( bp::override func_getUnclippedInnerRect_impl = this->get_override( "getUnclippedInnerRect_impl" ) )
            return func_getUnclippedInnerRect_impl(  );
        else{
            return this->CEGUI::Window::getUnclippedInnerRect_impl(  );
        }
    }
    
    ::CEGUI::Rect default_getUnclippedInnerRect_impl(  ) const  {
        return CEGUI::Window::getUnclippedInnerRect_impl( );
    }

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

    virtual bool isHit( ::CEGUI::Vector2 const & position, bool const allow_disabled=false ) const  {
        if( bp::override func_isHit = this->get_override( "isHit" ) )
            return func_isHit( boost::ref(position), allow_disabled );
        else{
            return this->CEGUI::Window::isHit( boost::ref(position), allow_disabled );
        }
    }
    
    bool default_isHit( ::CEGUI::Vector2 const & position, bool const allow_disabled=false ) const  {
        return CEGUI::Window::isHit( boost::ref(position), allow_disabled );
    }

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

    virtual void setLookNFeel( ::CEGUI::String const & look ) {
        if( bp::override func_setLookNFeel = this->get_override( "setLookNFeel" ) )
            func_setLookNFeel( boost::ref(look) );
        else{
            this->CEGUI::Window::setLookNFeel( boost::ref(look) );
        }
    }
    
    void default_setLookNFeel( ::CEGUI::String const & look ) {
        CEGUI::Window::setLookNFeel( boost::ref(look) );
    }

    virtual void setMargin( ::CEGUI::UBox const & margin ) {
        if( bp::override func_setMargin = this->get_override( "setMargin" ) )
            func_setMargin( boost::ref(margin) );
        else{
            this->CEGUI::Window::setMargin( boost::ref(margin) );
        }
    }
    
    void default_setMargin( ::CEGUI::UBox const & margin ) {
        CEGUI::Window::setMargin( boost::ref(margin) );
    }

    virtual ::CEGUI::RefCounted< CEGUI::BoundSlot > subscribeScriptedEvent( ::CEGUI::String const & name, ::CEGUI::String const & subscriber_name ) {
        if( bp::override func_subscribeScriptedEvent = this->get_override( "subscribeScriptedEvent" ) )
            return func_subscribeScriptedEvent( boost::ref(name), boost::ref(subscriber_name) );
        else{
            return this->CEGUI::EventSet::subscribeScriptedEvent( boost::ref(name), boost::ref(subscriber_name) );
        }
    }
    
    ::CEGUI::RefCounted< CEGUI::BoundSlot > default_subscribeScriptedEvent( ::CEGUI::String const & name, ::CEGUI::String const & subscriber_name ) {
        return CEGUI::EventSet::subscribeScriptedEvent( boost::ref(name), boost::ref(subscriber_name) );
    }

    virtual ::CEGUI::RefCounted< CEGUI::BoundSlot > subscribeScriptedEvent( ::CEGUI::String const & name, unsigned int group, ::CEGUI::String const & subscriber_name ) {
        if( bp::override func_subscribeScriptedEvent = this->get_override( "subscribeScriptedEvent" ) )
            return func_subscribeScriptedEvent( boost::ref(name), group, boost::ref(subscriber_name) );
        else{
            return this->CEGUI::EventSet::subscribeScriptedEvent( boost::ref(name), group, boost::ref(subscriber_name) );
        }
    }
    
    ::CEGUI::RefCounted< CEGUI::BoundSlot > default_subscribeScriptedEvent( ::CEGUI::String const & name, unsigned int group, ::CEGUI::String const & subscriber_name ) {
        return CEGUI::EventSet::subscribeScriptedEvent( boost::ref(name), group, boost::ref(subscriber_name) );
    }

    virtual void update( float elapsed ) {
        if( bp::override func_update = this->get_override( "update" ) )
            func_update( elapsed );
        else{
            this->CEGUI::Window::update( elapsed );
        }
    }
    
    void default_update( float elapsed ) {
        CEGUI::Window::update( elapsed );
    }

    virtual void writeXMLToStream( ::CEGUI::XMLSerializer & xml_stream ) const  {
        if( bp::override func_writeXMLToStream = this->get_override( "writeXMLToStream" ) )
            func_writeXMLToStream( boost::ref(xml_stream) );
        else{
            this->CEGUI::Window::writeXMLToStream( boost::ref(xml_stream) );
        }
    }
    
    void default_writeXMLToStream( ::CEGUI::XMLSerializer & xml_stream ) const  {
        CEGUI::Window::writeXMLToStream( boost::ref(xml_stream) );
    }

};

void register_Tooltip_class(){

    { //::CEGUI::Tooltip
        typedef bp::class_< Tooltip_wrapper, bp::bases< CEGUI::Window >, boost::noncopyable > Tooltip_exposer_t;
        Tooltip_exposer_t Tooltip_exposer = Tooltip_exposer_t( "Tooltip", "*!\n\
            \n\
                Base class for Tooltip widgets.\n\
                \n\
                The Tooltip class shows a simple pop-up window around the mouse position\n\
                with some text information.  The tool-tip fades in when the user hovers\n\
                with the mouse over a window which has tool-tip text set, and then fades\n\
                out after some pre-set time.\n\
        \n\
            \note\n\
                For Tooltip to work properly, you must specify a default tool-tip widget\n\
                type via System.setTooltip, or by setting a custom tool-tip object for\n\
                your Window(s).  Additionally, you need to ensure that time pulses are\n\
                properly passed to the system via System.injectTimePulse.\n\
            *\n", bp::init< CEGUI::String const &, CEGUI::String const & >(( bp::arg("type"), bp::arg("name") ), "************************************************************************\n\
            Object Construction and Destruction\n\
        ************************************************************************\n\
        *!\n\
        \n\
            Constructor for the Tooltip base class constructor\n\
         *\n") );
        bp::scope Tooltip_scope( Tooltip_exposer );
        { //::CEGUI::Tooltip::getDisplayTime
        
            typedef float ( ::CEGUI::Tooltip::*getDisplayTime_function_type )(  ) const;
            
            Tooltip_exposer.def( 
                "getDisplayTime"
                , getDisplayTime_function_type( &::CEGUI::Tooltip::getDisplayTime )
                , "*!\n\
                    \n\
                        Return the number of seconds the tooltip should be displayed for before it\
                        automatically\n\
                        de-activates itself.  0 indicates that the tooltip never timesout and auto-\
                        deactivates.\n\
            \n\
                    @return\n\
                        float value representing a number of seconds.\n\
                     *\n" );
        
        }
        { //::CEGUI::Tooltip::getFadeTime
        
            typedef float ( ::CEGUI::Tooltip::*getFadeTime_function_type )(  ) const;
            
            Tooltip_exposer.def( 
                "getFadeTime"
                , getFadeTime_function_type( &::CEGUI::Tooltip::getFadeTime )
                , "*!\n\
                    \n\
                        Return the number of seconds that should be taken to fade the tooltip into and out of\n\
                        visibility.\n\
            \n\
                    @return\n\
                        float value representing a number of seconds.\n\
                     *\n" );
        
        }
        { //::CEGUI::Tooltip::getHoverTime
        
            typedef float ( ::CEGUI::Tooltip::*getHoverTime_function_type )(  ) const;
            
            Tooltip_exposer.def( 
                "getHoverTime"
                , getHoverTime_function_type( &::CEGUI::Tooltip::getHoverTime )
                , "*!\n\
                    \n\
                        Return the number of seconds the mouse should hover stationary over the target window\
                        before\n\
                        the tooltip gets activated.\n\
            \n\
                    @return\n\
                        float value representing a number of seconds.\n\
                     *\n" );
        
        }
        { //::CEGUI::Tooltip::getTargetWindow
        
            typedef ::CEGUI::Window const * ( ::CEGUI::Tooltip::*getTargetWindow_function_type )(  ) ;
            
            Tooltip_exposer.def( 
                "getTargetWindow"
                , getTargetWindow_function_type( &::CEGUI::Tooltip::getTargetWindow )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
                    \n\
                        return the current target window for this Tooltip.\n\
            \n\
                    @return\n\
                        Pointer to the target window for this Tooltip or 0 for none.\n\
                    *\n" );
        
        }
        { //::CEGUI::Tooltip::getTextSize
        
            typedef ::CEGUI::Size ( ::CEGUI::Tooltip::*getTextSize_function_type )(  ) const;
            
            Tooltip_exposer.def( 
                "getTextSize"
                , getTextSize_function_type( &::CEGUI::Tooltip::getTextSize )
                , "*!\n\
                    \n\
                        Return the size of the area that will be occupied by the tooltip text, given\n\
                        any current formatting options.\n\
            \n\
                    @return\n\
                        Size object describing the size of the rendered tooltip text in pixels.\n\
                    *\n" );
        
        }
        { //::CEGUI::Tooltip::getTextSize_impl
        
            typedef ::CEGUI::Size ( ::CEGUI::Tooltip::*getTextSize_impl_function_type )(  ) const;
            typedef ::CEGUI::Size ( Tooltip_wrapper::*default_getTextSize_impl_function_type )(  ) const;
            
            Tooltip_exposer.def( 
                "getTextSize_impl"
                , getTextSize_impl_function_type(&::CEGUI::Tooltip::getTextSize_impl)
                , default_getTextSize_impl_function_type(&Tooltip_wrapper::default_getTextSize_impl) );
        
        }
        { //::CEGUI::Tooltip::positionSelf
        
            typedef void ( ::CEGUI::Tooltip::*positionSelf_function_type )(  ) ;
            
            Tooltip_exposer.def( 
                "positionSelf"
                , positionSelf_function_type( &::CEGUI::Tooltip::positionSelf )
                , "*!\n\
                    \n\
                        Causes the tooltip to position itself appropriately.\n\
            \n\
                    @return\n\
                        Nothing.\n\
                    *\n" );
        
        }
        { //::CEGUI::Tooltip::resetTimer
        
            typedef void ( ::CEGUI::Tooltip::*resetTimer_function_type )(  ) ;
            
            Tooltip_exposer.def( 
                "resetTimer"
                , resetTimer_function_type( &::CEGUI::Tooltip::resetTimer )
                , "*!\n\
                    \n\
                        Resets the timer on the tooltip when in the Active  Inactive states.  This is used\
                        internally\n\
                        to control the tooltip, it is not normally necessary to call this method yourself.\n\
            \n\
                    @return\n\
                        Nothing.\n\
                     *\n" );
        
        }
        { //::CEGUI::Tooltip::setDisplayTime
        
            typedef void ( ::CEGUI::Tooltip::*setDisplayTime_function_type )( float ) ;
            
            Tooltip_exposer.def( 
                "setDisplayTime"
                , setDisplayTime_function_type( &::CEGUI::Tooltip::setDisplayTime )
                , ( bp::arg("seconds") )
                , "*!\n\
                    \n\
                        Set the number of seconds the tooltip should be displayed for before it automatically\n\
                        de-activates itself.  0 indicates that the tooltip should never timesout and auto-\
                        deactivate.\n\
            \n\
                    @param seconds\n\
                        float value representing a number of seconds.\n\
            \n\
                    @return\n\
                        Nothing.\n\
                     *\n" );
        
        }
        { //::CEGUI::Tooltip::setFadeTime
        
            typedef void ( ::CEGUI::Tooltip::*setFadeTime_function_type )( float ) ;
            
            Tooltip_exposer.def( 
                "setFadeTime"
                , setFadeTime_function_type( &::CEGUI::Tooltip::setFadeTime )
                , ( bp::arg("seconds") )
                , "*!\n\
                    \n\
                        Set the number of seconds that should be taken to fade the tooltip into and out of\n\
                        visibility.\n\
            \n\
                    @param seconds\n\
                        float value representing a number of seconds.\n\
            \n\
                    @return\n\
                        Nothing.\n\
                     *\n" );
        
        }
        { //::CEGUI::Tooltip::setHoverTime
        
            typedef void ( ::CEGUI::Tooltip::*setHoverTime_function_type )( float ) ;
            
            Tooltip_exposer.def( 
                "setHoverTime"
                , setHoverTime_function_type( &::CEGUI::Tooltip::setHoverTime )
                , ( bp::arg("seconds") )
                , "*!\n\
                    \n\
                        Set the number of seconds the mouse should hover stationary over the target window\
                        before\n\
                        the tooltip gets activated.\n\
            \n\
                    @param seconds\n\
                        float value representing a number of seconds.\n\
            \n\
                    @return\n\
                        Nothing.\n\
                     *\n" );
        
        }
        { //::CEGUI::Tooltip::setTargetWindow
        
            typedef void ( ::CEGUI::Tooltip::*setTargetWindow_function_type )( ::CEGUI::Window * ) ;
            
            Tooltip_exposer.def( 
                "setTargetWindow"
                , setTargetWindow_function_type( &::CEGUI::Tooltip::setTargetWindow )
                , ( bp::arg("wnd") )
                , "************************************************************************\n\
                        Public interface\n\
                    ************************************************************************\n\
                    *!\n\
                    \n\
                        Sets the target window for the tooltip.  This used internally to manage tooltips, you\n\
                        should not have to call this yourself.\n\
            \n\
                    @param wnd\n\
                        Window object that the tooltip should be associated with (for now).\n\
            \n\
                    @return\n\
                        Nothing.\n\
                     *\n" );
        
        }
        { //::CEGUI::Tooltip::sizeSelf
        
            typedef void ( ::CEGUI::Tooltip::*sizeSelf_function_type )(  ) ;
            
            Tooltip_exposer.def( 
                "sizeSelf"
                , sizeSelf_function_type( &::CEGUI::Tooltip::sizeSelf )
                , "*!\n\
                    \n\
                        Causes the tooltip to resize itself appropriately.\n\
            \n\
                    @return\n\
                        Nothing.\n\
                    *\n" );
        
        }
        Tooltip_exposer.add_static_property( "EventDisplayTimeChanged"
                        , bp::make_getter( &CEGUI::Tooltip::EventDisplayTimeChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Tooltip_exposer.add_static_property( "EventFadeTimeChanged"
                        , bp::make_getter( &CEGUI::Tooltip::EventFadeTimeChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Tooltip_exposer.add_static_property( "EventHoverTimeChanged"
                        , bp::make_getter( &CEGUI::Tooltip::EventHoverTimeChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Tooltip_exposer.add_static_property( "EventTooltipActive"
                        , bp::make_getter( &CEGUI::Tooltip::EventTooltipActive
                                , bp::return_value_policy< bp::return_by_value >() ) );
        Tooltip_exposer.add_static_property( "EventTooltipInactive"
                        , bp::make_getter( &CEGUI::Tooltip::EventTooltipInactive
                                , bp::return_value_policy< bp::return_by_value >() ) );
        { //::CEGUI::Window::beginInitialisation
        
            typedef void ( ::CEGUI::Window::*beginInitialisation_function_type )(  ) ;
            typedef void ( Tooltip_wrapper::*default_beginInitialisation_function_type )(  ) ;
            
            Tooltip_exposer.def( 
                "beginInitialisation"
                , beginInitialisation_function_type(&::CEGUI::Window::beginInitialisation)
                , default_beginInitialisation_function_type(&Tooltip_wrapper::default_beginInitialisation) );
        
        }
        { //::CEGUI::Window::cloneChildWidgetsTo
        
            typedef void ( ::CEGUI::Window::*cloneChildWidgetsTo_function_type )( ::CEGUI::Window & ) const;
            typedef void ( Tooltip_wrapper::*default_cloneChildWidgetsTo_function_type )( ::CEGUI::Window & ) const;
            
            Tooltip_exposer.def( 
                "cloneChildWidgetsTo"
                , cloneChildWidgetsTo_function_type(&::CEGUI::Window::cloneChildWidgetsTo)
                , default_cloneChildWidgetsTo_function_type(&Tooltip_wrapper::default_cloneChildWidgetsTo)
                , ( bp::arg("target") ) );
        
        }
        { //::CEGUI::Window::clonePropertiesTo
        
            typedef void ( ::CEGUI::Window::*clonePropertiesTo_function_type )( ::CEGUI::Window & ) const;
            typedef void ( Tooltip_wrapper::*default_clonePropertiesTo_function_type )( ::CEGUI::Window & ) const;
            
            Tooltip_exposer.def( 
                "clonePropertiesTo"
                , clonePropertiesTo_function_type(&::CEGUI::Window::clonePropertiesTo)
                , default_clonePropertiesTo_function_type(&Tooltip_wrapper::default_clonePropertiesTo)
                , ( bp::arg("target") ) );
        
        }
        { //::CEGUI::Window::destroy
        
            typedef void ( ::CEGUI::Window::*destroy_function_type )(  ) ;
            typedef void ( Tooltip_wrapper::*default_destroy_function_type )(  ) ;
            
            Tooltip_exposer.def( 
                "destroy"
                , destroy_function_type(&::CEGUI::Window::destroy)
                , default_destroy_function_type(&Tooltip_wrapper::default_destroy) );
        
        }
        { //::CEGUI::Window::endInitialisation
        
            typedef void ( ::CEGUI::Window::*endInitialisation_function_type )(  ) ;
            typedef void ( Tooltip_wrapper::*default_endInitialisation_function_type )(  ) ;
            
            Tooltip_exposer.def( 
                "endInitialisation"
                , endInitialisation_function_type(&::CEGUI::Window::endInitialisation)
                , default_endInitialisation_function_type(&Tooltip_wrapper::default_endInitialisation) );
        
        }
        { //::CEGUI::EventSet::fireEvent
        
            typedef void ( ::CEGUI::EventSet::*fireEvent_function_type )( ::CEGUI::String const &,::CEGUI::EventArgs &,::CEGUI::String const & ) ;
            typedef void ( Tooltip_wrapper::*default_fireEvent_function_type )( ::CEGUI::String const &,::CEGUI::EventArgs &,::CEGUI::String const & ) ;
            
            Tooltip_exposer.def( 
                "fireEvent"
                , fireEvent_function_type(&::CEGUI::EventSet::fireEvent)
                , default_fireEvent_function_type(&Tooltip_wrapper::default_fireEvent)
                , ( bp::arg("name"), bp::arg("args"), bp::arg("eventNamespace")="" ) );
        
        }
        { //::CEGUI::Window::getRenderedStringParser
        
            typedef ::CEGUI::RenderedStringParser & ( ::CEGUI::Window::*getRenderedStringParser_function_type )(  ) const;
            
            Tooltip_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 ( Tooltip_wrapper::*default_getRenderingContext_impl_function_type )( ::CEGUI::RenderingContext & ) const;
            
            Tooltip_exposer.def( 
                "getRenderingContext_impl"
                , getRenderingContext_impl_function_type(&::CEGUI::Window::getRenderingContext_impl)
                , default_getRenderingContext_impl_function_type(&Tooltip_wrapper::default_getRenderingContext_impl)
                , ( bp::arg("ctx") ) );
        
        }
        { //::CEGUI::Window::getUnclippedInnerRect_impl
        
            typedef ::CEGUI::Rect ( ::CEGUI::Window::*getUnclippedInnerRect_impl_function_type )(  ) const;
            typedef ::CEGUI::Rect ( Tooltip_wrapper::*default_getUnclippedInnerRect_impl_function_type )(  ) const;
            
            Tooltip_exposer.def( 
                "getUnclippedInnerRect_impl"
                , getUnclippedInnerRect_impl_function_type(&::CEGUI::Window::getUnclippedInnerRect_impl)
                , default_getUnclippedInnerRect_impl_function_type(&Tooltip_wrapper::default_getUnclippedInnerRect_impl) );
        
        }
        { //::CEGUI::Window::initialiseComponents
        
            typedef void ( ::CEGUI::Window::*initialiseComponents_function_type )(  ) ;
            typedef void ( Tooltip_wrapper::*default_initialiseComponents_function_type )(  ) ;
            
            Tooltip_exposer.def( 
                "initialiseComponents"
                , initialiseComponents_function_type(&::CEGUI::Window::initialiseComponents)
                , default_initialiseComponents_function_type(&Tooltip_wrapper::default_initialiseComponents) );
        
        }
        { //::CEGUI::Window::isHit
        
            typedef bool ( ::CEGUI::Window::*isHit_function_type )( ::CEGUI::Vector2 const &,bool const ) const;
            typedef bool ( Tooltip_wrapper::*default_isHit_function_type )( ::CEGUI::Vector2 const &,bool const ) const;
            
            Tooltip_exposer.def( 
                "isHit"
                , isHit_function_type(&::CEGUI::Window::isHit)
                , default_isHit_function_type(&Tooltip_wrapper::default_isHit)
                , ( bp::arg("position"), bp::arg("allow_disabled")=(bool const)(false) ) );
        
        }
        { //::CEGUI::Window::performChildWindowLayout
        
            typedef void ( ::CEGUI::Window::*performChildWindowLayout_function_type )(  ) ;
            typedef void ( Tooltip_wrapper::*default_performChildWindowLayout_function_type )(  ) ;
            
            Tooltip_exposer.def( 
                "performChildWindowLayout"
                , performChildWindowLayout_function_type(&::CEGUI::Window::performChildWindowLayout)
                , default_performChildWindowLayout_function_type(&Tooltip_wrapper::default_performChildWindowLayout) );
        
        }
        { //::CEGUI::Window::setLookNFeel
        
            typedef void ( ::CEGUI::Window::*setLookNFeel_function_type )( ::CEGUI::String const & ) ;
            typedef void ( Tooltip_wrapper::*default_setLookNFeel_function_type )( ::CEGUI::String const & ) ;
            
            Tooltip_exposer.def( 
                "setLookNFeel"
                , setLookNFeel_function_type(&::CEGUI::Window::setLookNFeel)
                , default_setLookNFeel_function_type(&Tooltip_wrapper::default_setLookNFeel)
                , ( bp::arg("look") ) );
        
        }
        { //::CEGUI::Window::setMargin
        
            typedef void ( ::CEGUI::Window::*setMargin_function_type )( ::CEGUI::UBox const & ) ;
            typedef void ( Tooltip_wrapper::*default_setMargin_function_type )( ::CEGUI::UBox const & ) ;
            
            Tooltip_exposer.def( 
                "setMargin"
                , setMargin_function_type(&::CEGUI::Window::setMargin)
                , default_setMargin_function_type(&Tooltip_wrapper::default_setMargin)
                , ( bp::arg("margin") ) );
        
        }
        { //::CEGUI::EventSet::subscribeScriptedEvent
        
            typedef ::CEGUI::RefCounted< CEGUI::BoundSlot > ( ::CEGUI::EventSet::*subscribeScriptedEvent_function_type )( ::CEGUI::String const &,::CEGUI::String const & ) ;
            typedef ::CEGUI::RefCounted< CEGUI::BoundSlot > ( Tooltip_wrapper::*default_subscribeScriptedEvent_function_type )( ::CEGUI::String const &,::CEGUI::String const & ) ;
            
            Tooltip_exposer.def( 
                "subscribeScriptedEvent"
                , subscribeScriptedEvent_function_type(&::CEGUI::EventSet::subscribeScriptedEvent)
                , default_subscribeScriptedEvent_function_type(&Tooltip_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 > ( Tooltip_wrapper::*default_subscribeScriptedEvent_function_type )( ::CEGUI::String const &,unsigned int,::CEGUI::String const & ) ;
            
            Tooltip_exposer.def( 
                "subscribeScriptedEvent"
                , subscribeScriptedEvent_function_type(&::CEGUI::EventSet::subscribeScriptedEvent)
                , default_subscribeScriptedEvent_function_type(&Tooltip_wrapper::default_subscribeScriptedEvent)
                , ( bp::arg("name"), bp::arg("group"), bp::arg("subscriber_name") ) );
        
        }
        { //::CEGUI::Window::update
        
            typedef void ( ::CEGUI::Window::*update_function_type )( float ) ;
            typedef void ( Tooltip_wrapper::*default_update_function_type )( float ) ;
            
            Tooltip_exposer.def( 
                "update"
                , update_function_type(&::CEGUI::Window::update)
                , default_update_function_type(&Tooltip_wrapper::default_update)
                , ( bp::arg("elapsed") ) );
        
        }
        { //::CEGUI::Window::writeXMLToStream
        
            typedef void ( ::CEGUI::Window::*writeXMLToStream_function_type )( ::CEGUI::XMLSerializer & ) const;
            typedef void ( Tooltip_wrapper::*default_writeXMLToStream_function_type )( ::CEGUI::XMLSerializer & ) const;
            
            Tooltip_exposer.def( 
                "writeXMLToStream"
                , writeXMLToStream_function_type(&::CEGUI::Window::writeXMLToStream)
                , default_writeXMLToStream_function_type(&Tooltip_wrapper::default_writeXMLToStream)
                , ( bp::arg("xml_stream") ) );
        
        }
    }

}
