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

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

namespace bp = boost::python;

struct DragContainer_wrapper : CEGUI::DragContainer, bp::wrapper< CEGUI::DragContainer > {

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

    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::DragContainer::getRenderingContext_impl( boost::ref(ctx) );
        }
    }
    
    void default_getRenderingContext_impl( ::CEGUI::RenderingContext & ctx ) const  {
        CEGUI::DragContainer::getRenderingContext_impl( boost::ref(ctx) );
    }

    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 ::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_DragContainer_class(){

    { //::CEGUI::DragContainer
        typedef bp::class_< DragContainer_wrapper, bp::bases< CEGUI::Window >, boost::noncopyable > DragContainer_exposer_t;
        DragContainer_exposer_t DragContainer_exposer = DragContainer_exposer_t( "DragContainer", "*!\n\
        \n\
            Generic drag & drop enabled window class\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 DragContainer objects\n\
        *\n") );
        bp::scope DragContainer_scope( DragContainer_exposer );
        { //::CEGUI::DragContainer::getCurrentDropTarget
        
            typedef ::CEGUI::Window * ( ::CEGUI::DragContainer::*getCurrentDropTarget_function_type )(  ) const;
            
            DragContainer_exposer.def( 
                "getCurrentDropTarget"
                , getCurrentDropTarget_function_type( &::CEGUI::DragContainer::getCurrentDropTarget )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
                    \n\
                        Return the Window object that is the current drop target for the DragContainer.\n\
            \n\
                        The drop target for a DragContainer is basically the Window that the DragContainer\n\
                        is within while being dragged.  The drop target may be 0 to indicate no target.\n\
            \n\
                    @return\n\
                        Pointer to a Window object that contains the DragContainer whilst being dragged, or\n\
                        0 to indicate no current target.\n\
                    *\n" );
        
        }
        { //::CEGUI::DragContainer::getDragAlpha
        
            typedef float ( ::CEGUI::DragContainer::*getDragAlpha_function_type )(  ) const;
            
            DragContainer_exposer.def( 
                "getDragAlpha"
                , getDragAlpha_function_type( &::CEGUI::DragContainer::getDragAlpha )
                , "*!\n\
                    \n\
                        Return the alpha value that will be set on the DragContainer while a drag operation is\n\
                        in progress.\n\
            \n\
                    @return\n\
                        Current alpha value to use whilst dragging.\n\
                    *\n" );
        
        }
        { //::CEGUI::DragContainer::getDragCursorImage
        
            typedef ::CEGUI::Image const * ( ::CEGUI::DragContainer::*getDragCursorImage_function_type )(  ) const;
            
            DragContainer_exposer.def( 
                "getDragCursorImage"
                , getDragCursorImage_function_type( &::CEGUI::DragContainer::getDragCursorImage )
                , bp::return_value_policy< bp::reference_existing_object >()
                , "*!\n\
                    \n\
                        Return the Image currently set to be used for the mouse cursor when a\n\
                        drag operation is in progress.\n\
            \n\
                    @return\n\
                        Image object currently set to be used as the mouse cursor when dragging.\n\
                    *\n" );
        
        }
        { //::CEGUI::DragContainer::getFixedDragOffset
        
            typedef ::CEGUI::UVector2 const & ( ::CEGUI::DragContainer::*getFixedDragOffset_function_type )(  ) const;
            
            DragContainer_exposer.def( 
                "getFixedDragOffset"
                , getFixedDragOffset_function_type( &::CEGUI::DragContainer::getFixedDragOffset )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "*!\n\
                    \n\
                        Return the fixed mouse cursor dragging offset to be used for this\n\
                        DragContainer.\n\
            \n\
                    @return\n\
                        UVector2 describing the fixed offset used when dragging this\n\
                        DragContainer.\n\
            \n\
                    \note\n\
                        This offset is only used if it's use is enabled via the\n\
                        setUsingFixedDragOffset function.\n\
                    *\n" );
        
        }
        { //::CEGUI::DragContainer::getPixelDragThreshold
        
            typedef float ( ::CEGUI::DragContainer::*getPixelDragThreshold_function_type )(  ) const;
            
            DragContainer_exposer.def( 
                "getPixelDragThreshold"
                , getPixelDragThreshold_function_type( &::CEGUI::DragContainer::getPixelDragThreshold )
                , "*!\n\
                    \n\
                        Return the current drag threshold in pixels.\n\
            \n\
                        The drag threshold is the number of pixels that the mouse must be\n\
                        moved with the left button held down in order to commence a drag\n\
                        operation.\n\
                    \n\
                    @return\n\
                        float value indicating the current drag threshold value.\n\
                    *\n" );
        
        }
        { //::CEGUI::DragContainer::getRenderingContext_impl
        
            typedef void ( ::CEGUI::DragContainer::*getRenderingContext_impl_function_type )( ::CEGUI::RenderingContext & ) const;
            typedef void ( DragContainer_wrapper::*default_getRenderingContext_impl_function_type )( ::CEGUI::RenderingContext & ) const;
            
            DragContainer_exposer.def( 
                "getRenderingContext_impl"
                , getRenderingContext_impl_function_type(&::CEGUI::DragContainer::getRenderingContext_impl)
                , default_getRenderingContext_impl_function_type(&DragContainer_wrapper::default_getRenderingContext_impl)
                , ( bp::arg("ctx") ) );
        
        }
        { //::CEGUI::DragContainer::isBeingDragged
        
            typedef bool ( ::CEGUI::DragContainer::*isBeingDragged_function_type )(  ) const;
            
            DragContainer_exposer.def( 
                "isBeingDragged"
                , isBeingDragged_function_type( &::CEGUI::DragContainer::isBeingDragged )
                , "*!\n\
                    \n\
                        Return whether the DragContainer is currently being dragged.\n\
            \n\
                    @return\n\
                        - true if the DragContainer is being dragged.\n\
                        - false if te DragContainer is not being dragged.\n\
                    *\n" );
        
        }
        { //::CEGUI::DragContainer::isDraggingEnabled
        
            typedef bool ( ::CEGUI::DragContainer::*isDraggingEnabled_function_type )(  ) const;
            
            DragContainer_exposer.def( 
                "isDraggingEnabled"
                , isDraggingEnabled_function_type( &::CEGUI::DragContainer::isDraggingEnabled )
                , "*************************************************************************\n\
                     Public Interface to DragContainer\n\
                    *************************************************************************\n\
                    *!\n\
                    \n\
                        Return whether dragging is currently enabled for this DragContainer.\n\
            \n\
                    @return\n\
                        - true if dragging is enabled and the DragContainer may be dragged.\n\
                        - false if dragging is disabled and the DragContainer may not be dragged.\n\
                    *\n" );
        
        }
        { //::CEGUI::DragContainer::isStickyModeEnabled
        
            typedef bool ( ::CEGUI::DragContainer::*isStickyModeEnabled_function_type )(  ) const;
            
            DragContainer_exposer.def( 
                "isStickyModeEnabled"
                , isStickyModeEnabled_function_type( &::CEGUI::DragContainer::isStickyModeEnabled )
                , "*!\n\
                    \n\
                        Return whether sticky mode is enable or disabled.\n\
            \n\
                    @return\n\
                        - true if sticky mode is enabled.\n\
                        - false if sticky mode is disabled.\n\
                    *\n" );
        
        }
        { //::CEGUI::DragContainer::isUsingFixedDragOffset
        
            typedef bool ( ::CEGUI::DragContainer::*isUsingFixedDragOffset_function_type )(  ) const;
            
            DragContainer_exposer.def( 
                "isUsingFixedDragOffset"
                , isUsingFixedDragOffset_function_type( &::CEGUI::DragContainer::isUsingFixedDragOffset )
                , "*!\n\
                    \n\
                        Return whether the fixed dragging offset - as set with the\n\
                        setFixedDragOffset function - will be used, or whether the built-in\n\
                        positioning will be used.\n\
            \n\
                    @param enable\n\
                        - true to enabled the use of the fixed offset.\n\
                        - false to use the regular logic.\n\
                    *\n" );
        
        }
        { //::CEGUI::DragContainer::pickUp
        
            typedef bool ( ::CEGUI::DragContainer::*pickUp_function_type )( bool const ) ;
            
            DragContainer_exposer.def( 
                "pickUp"
                , pickUp_function_type( &::CEGUI::DragContainer::pickUp )
                , ( bp::arg("force_sticky")=(bool const)(false) )
                , "*!\n\
                    \n\
                        Immediately pick up the DragContainer and optionally set the sticky\n\
                        mode in order to allow this to happen.  Any current interaction\n\
                        (i.e. mouse capture) will be interrupted.\n\
            \n\
                    @param force_sticky\n\
                        - true to automatically enable the sticky mode in order to\n\
                        facilitate picking up the DragContainer.\n\
                        - false to ignore the pick up request if the sticky mode is not\n\
                        alraedy enabled (default).\n\
            \n\
                    @return\n\
                        - true if the DragContainer was successfully picked up.\n\
                        - false if the DragContainer was not picked up.\n\
                    *\n" );
        
        }
        { //::CEGUI::DragContainer::setDragAlpha
        
            typedef void ( ::CEGUI::DragContainer::*setDragAlpha_function_type )( float ) ;
            
            DragContainer_exposer.def( 
                "setDragAlpha"
                , setDragAlpha_function_type( &::CEGUI::DragContainer::setDragAlpha )
                , ( bp::arg("alpha") )
                , "*!\n\
                    \n\
                        Set the alpha value to be set on the DragContainer when a drag operation is\n\
                        in progress.\n\
            \n\
                        This method can be used while a drag is in progress to update the alpha.  Note that\n\
                        the normal setAlpha method does not affect alpha while a drag is in progress, but\n\
                        once the drag operation has ended, any value set via setAlpha will be restored.\n\
            \n\
                    @param alpha\n\
                        Alpha value to use whilst dragging.\n\
            \n\
                    @return\n\
                        Nothing.\n\
                    *\n" );
        
        }
        { //::CEGUI::DragContainer::setDragCursorImage
        
            typedef void ( ::CEGUI::DragContainer::*setDragCursorImage_function_type )( ::CEGUI::Image const * ) ;
            
            DragContainer_exposer.def( 
                "setDragCursorImage"
                , setDragCursorImage_function_type( &::CEGUI::DragContainer::setDragCursorImage )
                , ( bp::arg("image") )
                , "*!\n\
                    \n\
                        Set the Image to be used for the mouse cursor when a drag operation is\n\
                        in progress.\n\
            \n\
                        This method may be used during a drag operation to update the current mouse\n\
                        cursor image.\n\
            \n\
                    @param image\n\
                        Image object to be used as the mouse cursor while dragging.\n\
            \n\
                    @return\n\
                        Nothing.\n\
                    *\n" );
        
        }
        { //::CEGUI::DragContainer::setDragCursorImage
        
            typedef void ( ::CEGUI::DragContainer::*setDragCursorImage_function_type )( ::CEGUI::MouseCursorImage ) ;
            
            DragContainer_exposer.def( 
                "setDragCursorImage"
                , setDragCursorImage_function_type( &::CEGUI::DragContainer::setDragCursorImage )
                , ( bp::arg("image") )
                , "*!\n\
                    \n\
                        Set the Image to be used for the mouse cursor when a drag operation is\n\
                        in progress.\n\
            \n\
                        This method may be used during a drag operation to update the current mouse\n\
                        cursor image.\n\
            \n\
                    @param image\n\
                        One of the MouseCursorImage enumerated values.\n\
            \n\
                    @return\n\
                        Nothing.\n\
                    *\n" );
        
        }
        { //::CEGUI::DragContainer::setDragCursorImage
        
            typedef void ( ::CEGUI::DragContainer::*setDragCursorImage_function_type )( ::CEGUI::String const &,::CEGUI::String const & ) ;
            
            DragContainer_exposer.def( 
                "setDragCursorImage"
                , setDragCursorImage_function_type( &::CEGUI::DragContainer::setDragCursorImage )
                , ( bp::arg("imageset"), bp::arg("image") )
                , "*!\n\
                    \n\
                        Set the Image to be used for the mouse cursor when a drag operation is\n\
                        in progress.\n\
            \n\
                        This method may be used during a drag operation to update the current mouse\n\
                        cursor image.\n\
            \n\
                    @param imageset\n\
                        String holding the name of the Imageset that contains the Image to be used.\n\
            \n\
                    @param image\n\
                        Image defined for the Imageset  imageset to be used as the mouse cursor\n\
                        when dragging.\n\
            \n\
                    @return\n\
                        Nothing.\n\
            \n\
                    @exception UnknownObjectException   thrown if either  imageset or  image are unknown.\n\
                    *\n" );
        
        }
        { //::CEGUI::DragContainer::setDraggingEnabled
        
            typedef void ( ::CEGUI::DragContainer::*setDraggingEnabled_function_type )( bool ) ;
            
            DragContainer_exposer.def( 
                "setDraggingEnabled"
                , setDraggingEnabled_function_type( &::CEGUI::DragContainer::setDraggingEnabled )
                , ( bp::arg("setting") )
                , "*!\n\
                    \n\
                        Set whether dragging is currently enabled for this DragContainer.\n\
            \n\
                    @param setting\n\
                        - true to enable dragging so that the DragContainer may be dragged.\n\
                        - false to disabled dragging so that the DragContainer may not be dragged.\n\
            \n\
                    @return\n\
                        Nothing.\n\
                    *\n" );
        
        }
        { //::CEGUI::DragContainer::setFixedDragOffset
        
            typedef void ( ::CEGUI::DragContainer::*setFixedDragOffset_function_type )( ::CEGUI::UVector2 const & ) ;
            
            DragContainer_exposer.def( 
                "setFixedDragOffset"
                , setFixedDragOffset_function_type( &::CEGUI::DragContainer::setFixedDragOffset )
                , ( bp::arg("offset") )
                , "*!\n\
                    \n\
                        Set the fixed mouse cursor dragging offset to be used for this\n\
                        DragContainer.\n\
            \n\
                    @param offset\n\
                        UVector2 describing the fixed offset to be used when dragging this\n\
                        DragContainer.\n\
            \n\
                    \note\n\
                        This offset is only used if it's use is enabled via the\n\
                        setUsingFixedDragOffset function.\n\
                    *\n" );
        
        }
        { //::CEGUI::DragContainer::setPixelDragThreshold
        
            typedef void ( ::CEGUI::DragContainer::*setPixelDragThreshold_function_type )( float ) ;
            
            DragContainer_exposer.def( 
                "setPixelDragThreshold"
                , setPixelDragThreshold_function_type( &::CEGUI::DragContainer::setPixelDragThreshold )
                , ( bp::arg("pixels") )
                , "*!\n\
                    \n\
                        Set the current drag threshold in pixels.\n\
            \n\
                        The drag threshold is the number of pixels that the mouse must be\n\
                        moved with the left button held down in order to commence a drag\n\
                        operation.\n\
            \n\
                    @param pixels\n\
                        float value indicating the new drag threshold value.\n\
            \n\
                    @return\n\
                        Nothing.\n\
                    *\n" );
        
        }
        { //::CEGUI::DragContainer::setStickyModeEnabled
        
            typedef void ( ::CEGUI::DragContainer::*setStickyModeEnabled_function_type )( bool ) ;
            
            DragContainer_exposer.def( 
                "setStickyModeEnabled"
                , setStickyModeEnabled_function_type( &::CEGUI::DragContainer::setStickyModeEnabled )
                , ( bp::arg("setting") )
                , "*!\n\
                    \n\
                        Enable or disable sticky mode.\n\
            \n\
                    @param setting\n\
                        - true to enable sticky mode.\n\
                        - false to disable sticky mode.\n\
                    *\n" );
        
        }
        { //::CEGUI::DragContainer::setUsingFixedDragOffset
        
            typedef void ( ::CEGUI::DragContainer::*setUsingFixedDragOffset_function_type )( bool const ) ;
            
            DragContainer_exposer.def( 
                "setUsingFixedDragOffset"
                , setUsingFixedDragOffset_function_type( &::CEGUI::DragContainer::setUsingFixedDragOffset )
                , ( bp::arg("enable") )
                , "*!\n\
                    \n\
                        Set whether the fixed dragging offset - as set with the\n\
                        setFixedDragOffset - function will be used, or whether the built-in\n\
                        positioning will be used.\n\
            \n\
                    @param enable\n\
                        - true to enabled the use of the fixed offset.\n\
                        - false to use the regular logic.\n\
                    *\n" );
        
        }
        DragContainer_exposer.add_static_property( "EventDragAlphaChanged"
                        , bp::make_getter( &CEGUI::DragContainer::EventDragAlphaChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        DragContainer_exposer.add_static_property( "EventDragDropTargetChanged"
                        , bp::make_getter( &CEGUI::DragContainer::EventDragDropTargetChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        DragContainer_exposer.add_static_property( "EventDragEnabledChanged"
                        , bp::make_getter( &CEGUI::DragContainer::EventDragEnabledChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        DragContainer_exposer.add_static_property( "EventDragEnded"
                        , bp::make_getter( &CEGUI::DragContainer::EventDragEnded
                                , bp::return_value_policy< bp::return_by_value >() ) );
        DragContainer_exposer.add_static_property( "EventDragMouseCursorChanged"
                        , bp::make_getter( &CEGUI::DragContainer::EventDragMouseCursorChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        DragContainer_exposer.add_static_property( "EventDragPositionChanged"
                        , bp::make_getter( &CEGUI::DragContainer::EventDragPositionChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        DragContainer_exposer.add_static_property( "EventDragStarted"
                        , bp::make_getter( &CEGUI::DragContainer::EventDragStarted
                                , bp::return_value_policy< bp::return_by_value >() ) );
        DragContainer_exposer.add_static_property( "EventDragThresholdChanged"
                        , bp::make_getter( &CEGUI::DragContainer::EventDragThresholdChanged
                                , bp::return_value_policy< bp::return_by_value >() ) );
        { //::CEGUI::Window::beginInitialisation
        
            typedef void ( ::CEGUI::Window::*beginInitialisation_function_type )(  ) ;
            typedef void ( DragContainer_wrapper::*default_beginInitialisation_function_type )(  ) ;
            
            DragContainer_exposer.def( 
                "beginInitialisation"
                , beginInitialisation_function_type(&::CEGUI::Window::beginInitialisation)
                , default_beginInitialisation_function_type(&DragContainer_wrapper::default_beginInitialisation) );
        
        }
        { //::CEGUI::Window::cloneChildWidgetsTo
        
            typedef void ( ::CEGUI::Window::*cloneChildWidgetsTo_function_type )( ::CEGUI::Window & ) const;
            typedef void ( DragContainer_wrapper::*default_cloneChildWidgetsTo_function_type )( ::CEGUI::Window & ) const;
            
            DragContainer_exposer.def( 
                "cloneChildWidgetsTo"
                , cloneChildWidgetsTo_function_type(&::CEGUI::Window::cloneChildWidgetsTo)
                , default_cloneChildWidgetsTo_function_type(&DragContainer_wrapper::default_cloneChildWidgetsTo)
                , ( bp::arg("target") ) );
        
        }
        { //::CEGUI::Window::clonePropertiesTo
        
            typedef void ( ::CEGUI::Window::*clonePropertiesTo_function_type )( ::CEGUI::Window & ) const;
            typedef void ( DragContainer_wrapper::*default_clonePropertiesTo_function_type )( ::CEGUI::Window & ) const;
            
            DragContainer_exposer.def( 
                "clonePropertiesTo"
                , clonePropertiesTo_function_type(&::CEGUI::Window::clonePropertiesTo)
                , default_clonePropertiesTo_function_type(&DragContainer_wrapper::default_clonePropertiesTo)
                , ( bp::arg("target") ) );
        
        }
        { //::CEGUI::Window::destroy
        
            typedef void ( ::CEGUI::Window::*destroy_function_type )(  ) ;
            typedef void ( DragContainer_wrapper::*default_destroy_function_type )(  ) ;
            
            DragContainer_exposer.def( 
                "destroy"
                , destroy_function_type(&::CEGUI::Window::destroy)
                , default_destroy_function_type(&DragContainer_wrapper::default_destroy) );
        
        }
        { //::CEGUI::Window::endInitialisation
        
            typedef void ( ::CEGUI::Window::*endInitialisation_function_type )(  ) ;
            typedef void ( DragContainer_wrapper::*default_endInitialisation_function_type )(  ) ;
            
            DragContainer_exposer.def( 
                "endInitialisation"
                , endInitialisation_function_type(&::CEGUI::Window::endInitialisation)
                , default_endInitialisation_function_type(&DragContainer_wrapper::default_endInitialisation) );
        
        }
        { //::CEGUI::EventSet::fireEvent
        
            typedef void ( ::CEGUI::EventSet::*fireEvent_function_type )( ::CEGUI::String const &,::CEGUI::EventArgs &,::CEGUI::String const & ) ;
            typedef void ( DragContainer_wrapper::*default_fireEvent_function_type )( ::CEGUI::String const &,::CEGUI::EventArgs &,::CEGUI::String const & ) ;
            
            DragContainer_exposer.def( 
                "fireEvent"
                , fireEvent_function_type(&::CEGUI::EventSet::fireEvent)
                , default_fireEvent_function_type(&DragContainer_wrapper::default_fireEvent)
                , ( bp::arg("name"), bp::arg("args"), bp::arg("eventNamespace")="" ) );
        
        }
        { //::CEGUI::Window::getRenderedStringParser
        
            typedef ::CEGUI::RenderedStringParser & ( ::CEGUI::Window::*getRenderedStringParser_function_type )(  ) const;
            
            DragContainer_exposer.def( 
                "getRenderedStringParser"
                , getRenderedStringParser_function_type(&::CEGUI::Window::getRenderedStringParser)
                , bp::return_value_policy< bp::reference_existing_object >() );
        
        }
        { //::CEGUI::Window::getUnclippedInnerRect_impl
        
            typedef ::CEGUI::Rect ( ::CEGUI::Window::*getUnclippedInnerRect_impl_function_type )(  ) const;
            typedef ::CEGUI::Rect ( DragContainer_wrapper::*default_getUnclippedInnerRect_impl_function_type )(  ) const;
            
            DragContainer_exposer.def( 
                "getUnclippedInnerRect_impl"
                , getUnclippedInnerRect_impl_function_type(&::CEGUI::Window::getUnclippedInnerRect_impl)
                , default_getUnclippedInnerRect_impl_function_type(&DragContainer_wrapper::default_getUnclippedInnerRect_impl) );
        
        }
        { //::CEGUI::Window::initialiseComponents
        
            typedef void ( ::CEGUI::Window::*initialiseComponents_function_type )(  ) ;
            typedef void ( DragContainer_wrapper::*default_initialiseComponents_function_type )(  ) ;
            
            DragContainer_exposer.def( 
                "initialiseComponents"
                , initialiseComponents_function_type(&::CEGUI::Window::initialiseComponents)
                , default_initialiseComponents_function_type(&DragContainer_wrapper::default_initialiseComponents) );
        
        }
        { //::CEGUI::Window::isHit
        
            typedef bool ( ::CEGUI::Window::*isHit_function_type )( ::CEGUI::Vector2 const &,bool const ) const;
            typedef bool ( DragContainer_wrapper::*default_isHit_function_type )( ::CEGUI::Vector2 const &,bool const ) const;
            
            DragContainer_exposer.def( 
                "isHit"
                , isHit_function_type(&::CEGUI::Window::isHit)
                , default_isHit_function_type(&DragContainer_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 ( DragContainer_wrapper::*default_performChildWindowLayout_function_type )(  ) ;
            
            DragContainer_exposer.def( 
                "performChildWindowLayout"
                , performChildWindowLayout_function_type(&::CEGUI::Window::performChildWindowLayout)
                , default_performChildWindowLayout_function_type(&DragContainer_wrapper::default_performChildWindowLayout) );
        
        }
        { //::CEGUI::Window::setLookNFeel
        
            typedef void ( ::CEGUI::Window::*setLookNFeel_function_type )( ::CEGUI::String const & ) ;
            typedef void ( DragContainer_wrapper::*default_setLookNFeel_function_type )( ::CEGUI::String const & ) ;
            
            DragContainer_exposer.def( 
                "setLookNFeel"
                , setLookNFeel_function_type(&::CEGUI::Window::setLookNFeel)
                , default_setLookNFeel_function_type(&DragContainer_wrapper::default_setLookNFeel)
                , ( bp::arg("look") ) );
        
        }
        { //::CEGUI::Window::setMargin
        
            typedef void ( ::CEGUI::Window::*setMargin_function_type )( ::CEGUI::UBox const & ) ;
            typedef void ( DragContainer_wrapper::*default_setMargin_function_type )( ::CEGUI::UBox const & ) ;
            
            DragContainer_exposer.def( 
                "setMargin"
                , setMargin_function_type(&::CEGUI::Window::setMargin)
                , default_setMargin_function_type(&DragContainer_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 > ( DragContainer_wrapper::*default_subscribeScriptedEvent_function_type )( ::CEGUI::String const &,::CEGUI::String const & ) ;
            
            DragContainer_exposer.def( 
                "subscribeScriptedEvent"
                , subscribeScriptedEvent_function_type(&::CEGUI::EventSet::subscribeScriptedEvent)
                , default_subscribeScriptedEvent_function_type(&DragContainer_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 > ( DragContainer_wrapper::*default_subscribeScriptedEvent_function_type )( ::CEGUI::String const &,unsigned int,::CEGUI::String const & ) ;
            
            DragContainer_exposer.def( 
                "subscribeScriptedEvent"
                , subscribeScriptedEvent_function_type(&::CEGUI::EventSet::subscribeScriptedEvent)
                , default_subscribeScriptedEvent_function_type(&DragContainer_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 ( DragContainer_wrapper::*default_update_function_type )( float ) ;
            
            DragContainer_exposer.def( 
                "update"
                , update_function_type(&::CEGUI::Window::update)
                , default_update_function_type(&DragContainer_wrapper::default_update)
                , ( bp::arg("elapsed") ) );
        
        }
        { //::CEGUI::Window::writeXMLToStream
        
            typedef void ( ::CEGUI::Window::*writeXMLToStream_function_type )( ::CEGUI::XMLSerializer & ) const;
            typedef void ( DragContainer_wrapper::*default_writeXMLToStream_function_type )( ::CEGUI::XMLSerializer & ) const;
            
            DragContainer_exposer.def( 
                "writeXMLToStream"
                , writeXMLToStream_function_type(&::CEGUI::Window::writeXMLToStream)
                , default_writeXMLToStream_function_type(&DragContainer_wrapper::default_writeXMLToStream)
                , ( bp::arg("xml_stream") ) );
        
        }
    }

}
