Beispiel #1
0
void register_ExtensionsModuleViewer_class() {

    {   //::osiris::ExtensionsModuleViewer
        typedef ::boost::python::class_< ExtensionsModuleViewer_wrapper, ::boost::python::bases< ::osiris::ExtensionsModuleControl >, ::boost::noncopyable > ExtensionsModuleViewer_exposer_t;
        ExtensionsModuleViewer_exposer_t ExtensionsModuleViewer_exposer = ExtensionsModuleViewer_exposer_t( "ExtensionsModuleViewer", ::boost::python::init< >() );
        ::boost::python::scope ExtensionsModuleViewer_scope( ExtensionsModuleViewer_exposer );
        {   //::osiris::ExtensionsModuleViewer::getShowBlock

            typedef bool ( ::osiris::ExtensionsModuleViewer::*getShowBlock_function_type )(  ) const;
            typedef bool ( ExtensionsModuleViewer_wrapper::*default_getShowBlock_function_type )(  ) const;

            ExtensionsModuleViewer_exposer.def(
                "getShowBlock"
                , getShowBlock_function_type(&::osiris::ExtensionsModuleViewer::getShowBlock)
                , default_getShowBlock_function_type(&ExtensionsModuleViewer_wrapper::default_getShowBlock) );

        }
        {   //::osiris::IHtmlControl::decodeEvent

            typedef bool ( ExtensionsModuleViewer_wrapper::*decodeEvent_function_type )( ::osiris::String const &,::osiris::String &,::osiris::HtmlEvent & ) const;

            ExtensionsModuleViewer_exposer.def(
                "decodeEvent"
                , decodeEvent_function_type( &ExtensionsModuleViewer_wrapper::decodeEvent )
                , ( ::boost::python::arg("command"), ::boost::python::arg("eventName"), ::boost::python::arg("e") ) );

        }
        {   //::osiris::IHtmlControl::encodeEvent

            typedef ::osiris::String ( ExtensionsModuleViewer_wrapper::*encodeEvent_function_type )( ::osiris::String const &,::osiris::HtmlEvent const * ) const;

            ExtensionsModuleViewer_exposer.def(
                "encodeEvent"
                , encodeEvent_function_type( &ExtensionsModuleViewer_wrapper::encodeEvent )
                , ( ::boost::python::arg("eventName"), ::boost::python::arg("e")=(nullptr) ) );

        }
        {   //::osiris::IHtmlControl::getSession

            typedef ::boost::shared_ptr< osiris::HttpSession > ( ::osiris::IHtmlControl::*getSession_function_type )(  ) const;
            typedef ::boost::shared_ptr< osiris::HttpSession > ( ExtensionsModuleViewer_wrapper::*default_getSession_function_type )(  ) const;

            ExtensionsModuleViewer_exposer.def(
                "getSession"
                , getSession_function_type(&::osiris::IHtmlControl::getSession)
                , default_getSession_function_type(&ExtensionsModuleViewer_wrapper::default_getSession) );

        }
        {   //::osiris::ExtensionsModuleControl::init

            typedef bool ( ::osiris::ExtensionsModuleControl::*init_function_type )( ::boost::shared_ptr< osiris::IExtensionsModule >,::osiris::String const &,::osiris::UniqueID const &,::osiris::String const & ) ;
            typedef bool ( ExtensionsModuleViewer_wrapper::*default_init_function_type )( ::boost::shared_ptr< osiris::IExtensionsModule >,::osiris::String const &,::osiris::UniqueID const &,::osiris::String const & ) ;

            ExtensionsModuleViewer_exposer.def(
                "init"
                , init_function_type(&::osiris::ExtensionsModuleControl::init)
                , default_init_function_type(&ExtensionsModuleViewer_wrapper::default_init)
                , ( ::boost::python::arg("module"), ::boost::python::arg("title"), ::boost::python::arg("instance"), ::boost::python::arg("xml") ) );

        }
        {   //::osiris::IHtmlControl::onEvent

            typedef void ( ExtensionsModuleViewer_wrapper::*onEvent_function_type )( ::osiris::String const &,::osiris::IEvent * ) ;

            ExtensionsModuleViewer_exposer.def(
                "onEvent"
                , onEvent_function_type( &ExtensionsModuleViewer_wrapper::default_onEvent )
                , ( ::boost::python::arg("name"), ::boost::python::arg("e")=(nullptr) ) );

        }
        {   //::osiris::IHtmlControl::onInit

            typedef void ( ExtensionsModuleViewer_wrapper::*onInit_function_type )(  ) ;

            ExtensionsModuleViewer_exposer.def(
                "onInit"
                , onInit_function_type( &ExtensionsModuleViewer_wrapper::default_onInit ) );

        }
        {   //::osiris::IHtmlControl::onLoad

            typedef void ( ExtensionsModuleViewer_wrapper::*onLoad_function_type )(  ) ;

            ExtensionsModuleViewer_exposer.def(
                "onLoad"
                , onLoad_function_type( &ExtensionsModuleViewer_wrapper::default_onLoad ) );

        }
        {   //::osiris::IHtmlControl::onLoadViewState

            typedef void ( ExtensionsModuleViewer_wrapper::*onLoadViewState_function_type )( ::osiris::DataTree const & ) ;

            ExtensionsModuleViewer_exposer.def(
                "onLoadViewState"
                , onLoadViewState_function_type( &ExtensionsModuleViewer_wrapper::default_onLoadViewState )
                , ( ::boost::python::arg("state") ) );

        }
        {   //::osiris::IHtmlControl::onPreRender

            typedef void ( ExtensionsModuleViewer_wrapper::*onPreRender_function_type )(  ) ;

            ExtensionsModuleViewer_exposer.def(
                "onPreRender"
                , onPreRender_function_type( &ExtensionsModuleViewer_wrapper::default_onPreRender ) );

        }
        {   //::osiris::HtmlDiv::onRender

            typedef void ( ExtensionsModuleViewer_wrapper::*onRender_function_type )( ::osiris::HtmlWriter & ) ;

            ExtensionsModuleViewer_exposer.def(
                "onRender"
                , onRender_function_type( &ExtensionsModuleViewer_wrapper::default_onRender )
                , ( ::boost::python::arg("writer") ) );

        }
        {   //::osiris::IHtmlControl::onSaveViewState

            typedef void ( ExtensionsModuleViewer_wrapper::*onSaveViewState_function_type )( ::osiris::DataTree & ) ;

            ExtensionsModuleViewer_exposer.def(
                "onSaveViewState"
                , onSaveViewState_function_type( &ExtensionsModuleViewer_wrapper::default_onSaveViewState )
                , ( ::boost::python::arg("state") ) );

        }
        {   //::osiris::IHtmlControl::renderAttributes

            typedef void ( ::osiris::IHtmlControl::*renderAttributes_function_type )( ::osiris::HtmlWriter & ) ;
            typedef void ( ExtensionsModuleViewer_wrapper::*default_renderAttributes_function_type )( ::osiris::HtmlWriter & ) ;

            ExtensionsModuleViewer_exposer.def(
                "renderAttributes"
                , renderAttributes_function_type(&::osiris::IHtmlControl::renderAttributes)
                , default_renderAttributes_function_type(&ExtensionsModuleViewer_wrapper::default_renderAttributes)
                , ( ::boost::python::arg("writer") ) );

        }
        {   //::osiris::IHtmlControl::renderChilds

            typedef void ( ::osiris::IHtmlControl::*renderChilds_function_type )( ::osiris::HtmlWriter & ) ;
            typedef void ( ExtensionsModuleViewer_wrapper::*default_renderChilds_function_type )( ::osiris::HtmlWriter & ) ;

            ExtensionsModuleViewer_exposer.def(
                "renderChilds"
                , renderChilds_function_type(&::osiris::IHtmlControl::renderChilds)
                , default_renderChilds_function_type(&ExtensionsModuleViewer_wrapper::default_renderChilds)
                , ( ::boost::python::arg("writer") ) );

        }
        {   //::osiris::IHtmlControl::saveViewState

            typedef void ( ExtensionsModuleViewer_wrapper::*saveViewState_function_type )( ::osiris::DataTree & ) ;

            ExtensionsModuleViewer_exposer.def(
                "saveViewState"
                , saveViewState_function_type( &ExtensionsModuleViewer_wrapper::saveViewState )
                , ( ::boost::python::arg("states") ) );

        }
        {   //property "showBlock"[fget=::osiris::ExtensionsModuleViewer::getShowBlock]

            typedef bool ( ::osiris::ExtensionsModuleViewer::*fget )(  ) const;

            ExtensionsModuleViewer_exposer.add_property(
                "showBlock"
                , fget( &::osiris::ExtensionsModuleViewer::getShowBlock )
                , "get property, built on top of \"bool osiris::ExtensionsModuleViewer::getShowBlock() const [member function]\"" );

        }
        ::boost::python::register_ptr_to_python< boost::shared_ptr< ::osiris::ExtensionsModuleViewer > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::ExtensionsModuleViewer >, boost::shared_ptr< ::osiris::ExtensionsModuleControl > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::ExtensionsModuleViewer >, boost::shared_ptr< ::osiris::IPortalPageControl< osiris::HtmlDiv > > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::ExtensionsModuleViewer >, boost::shared_ptr< ::osiris::IPageControl< osiris::HtmlDiv > > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::ExtensionsModuleViewer >, boost::shared_ptr< ::boost::noncopyable_::noncopyable > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::ExtensionsModuleViewer >, boost::shared_ptr< ::boost::signals::trackable > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::ExtensionsModuleViewer >, boost::shared_ptr< ::osiris::enable_this_ptr< osiris::IHtmlControl > > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::ExtensionsModuleViewer >, boost::shared_ptr< ::osiris::Object > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::ExtensionsInvalidModule >, boost::shared_ptr< ::osiris::ExtensionsModuleViewer > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::ExtensionsModuleViewerHidden >, boost::shared_ptr< ::osiris::ExtensionsModuleViewer > >();
    }

}
Beispiel #2
0
void register_Input_class(){

    { //::xfx::Input
        typedef bp::class_< xfx::Input, bp::bases< xfx::Singleton< xfx::Input > >, boost::noncopyable > Input_exposer_t;
        Input_exposer_t Input_exposer = Input_exposer_t( "Input", bp::no_init );
        bp::scope Input_scope( Input_exposer );
        bp::enum_< xfx::Input::KeysType>("KeysType")
            .value("MOUSE_LBUTTON", xfx::Input::MOUSE_LBUTTON)
            .value("MOUSE_RBUTTON", xfx::Input::MOUSE_RBUTTON)
            .value("MOUSE_MBUTTON", xfx::Input::MOUSE_MBUTTON)
            .value("MOUSE_4BUTTON", xfx::Input::MOUSE_4BUTTON)
            .value("MOUSE_MOVELEFT", xfx::Input::MOUSE_MOVELEFT)
            .value("MOUSE_MOVERIGHT", xfx::Input::MOUSE_MOVERIGHT)
            .value("MOUSE_MOVEDOWN", xfx::Input::MOUSE_MOVEDOWN)
            .value("MOUSE_MOVEUP", xfx::Input::MOUSE_MOVEUP)
            .value("MOUSE_WHEELUP", xfx::Input::MOUSE_WHEELUP)
            .value("MOUSE_WHEELDOWN", xfx::Input::MOUSE_WHEELDOWN)
            .value("MAX_KEYS", xfx::Input::MAX_KEYS)
            .export_values()
            ;
        bp::enum_< xfx::Input::STATES>("STATES")
            .value("FIRST_PUSHED", xfx::Input::FIRST_PUSHED)
            .value("PUSHED", xfx::Input::PUSHED)
            .value("POPED", xfx::Input::POPED)
            .value("MAX_STATES", xfx::Input::MAX_STATES)
            .export_values()
            ;
        { //::xfx::Input::Cmd_bind
        
            typedef void ( ::xfx::Input::*cmd_bind_function_type )( bool,::xfx::String const & ) ;
            
            Input_exposer.def( 
                "cmd_bind"
                , cmd_bind_function_type( &::xfx::Input::Cmd_bind )
                , ( bp::arg("in_console"), bp::arg("str") ) );
        
        }
        { //::xfx::Input::Command
        
            typedef void ( ::xfx::Input::*command_function_type )( unsigned int,::xfx::Input::STATES,::xfx::String const & ) ;
            
            Input_exposer.def( 
                "command"
                , command_function_type( &::xfx::Input::Command )
                , ( bp::arg("key"), bp::arg("state"), bp::arg("cmd") ) );
        
        }
        { //::xfx::Input::Command
        
            typedef ::xfx::String const & ( ::xfx::Input::*command_function_type )( unsigned int,::xfx::Input::STATES ) const;
            
            Input_exposer.def( 
                "command"
                , command_function_type( &::xfx::Input::Command )
                , ( bp::arg("key"), bp::arg("state") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::xfx::Input::GetKeyForCommand
        
            typedef unsigned int ( ::xfx::Input::*get_key_for_command_function_type )( ::xfx::String const & ) const;
            
            Input_exposer.def( 
                "get_key_for_command"
                , get_key_for_command_function_type( &::xfx::Input::GetKeyForCommand )
                , ( bp::arg("command") ) );
        
        }
        { //::xfx::Input::Init
        
            typedef ::HRESULT ( ::xfx::Input::*init_function_type )(  ) ;
            
            Input_exposer.def( 
                "init"
                , init_function_type( &::xfx::Input::Init ) );
        
        }
        { //::xfx::Input::KeyCodeByName
        
            typedef unsigned int ( ::xfx::Input::*key_code_by_name_function_type )( char const * ) const;
            
            Input_exposer.def( 
                "key_code_by_name"
                , key_code_by_name_function_type( &::xfx::Input::KeyCodeByName )
                , ( bp::arg("name") ) );
        
        }
        { //::xfx::Input::KeyName
        
            typedef char const * ( ::xfx::Input::*key_name_function_type )( unsigned int ) const;
            
            Input_exposer.def( 
                "key_name"
                , key_name_function_type( &::xfx::Input::KeyName )
                , ( bp::arg("key") ) );
        
        }
        { //::xfx::Input::RetrieveData
        
            typedef void ( ::xfx::Input::*retrieve_data_function_type )(  ) ;
            
            Input_exposer.def( 
                "retrieve_data"
                , retrieve_data_function_type( &::xfx::Input::RetrieveData ) );
        
        }
        { //::xfx::Input::SetMouseMode
        
            typedef void ( ::xfx::Input::*set_mouse_mode_function_type )( bool const & ) ;
            
            Input_exposer.def( 
                "set_mouse_mode"
                , set_mouse_mode_function_type( &::xfx::Input::SetMouseMode )
                , ( bp::arg("isexclusive") ) );
        
        }
        { //::xfx::Input::Shutdown
        
            typedef ::HRESULT ( ::xfx::Input::*shutdown_function_type )(  ) ;
            
            Input_exposer.def( 
                "shutdown"
                , shutdown_function_type( &::xfx::Input::Shutdown ) );
        
        }
        { //::xfx::Input::TestKey
        
            typedef bool ( ::xfx::Input::*test_key_function_type )( unsigned int ) const;
            
            Input_exposer.def( 
                "test_key"
                , test_key_function_type( &::xfx::Input::TestKey )
                , ( bp::arg("key") ) );
        
        }
        { //::xfx::Input::TestKey
        
            typedef bool ( ::xfx::Input::*test_key_function_type )( char const * ) const;
            
            Input_exposer.def( 
                "test_key"
                , test_key_function_type( &::xfx::Input::TestKey )
                , ( bp::arg("key") ) );
        
        }
        { //::xfx::Input::TestKeyPressed
        
            typedef bool ( ::xfx::Input::*test_key_pressed_function_type )( unsigned int ) const;
            
            Input_exposer.def( 
                "test_key_pressed"
                , test_key_pressed_function_type( &::xfx::Input::TestKeyPressed )
                , ( bp::arg("key") ) );
        
        }
        { //::xfx::Input::TestKeyPressed
        
            typedef bool ( ::xfx::Input::*test_key_pressed_function_type )( char const * ) const;
            
            Input_exposer.def( 
                "test_key_pressed"
                , test_key_pressed_function_type( &::xfx::Input::TestKeyPressed )
                , ( bp::arg("key") ) );
        
        }
        { //::xfx::Input::TestKeyReleased
        
            typedef bool ( ::xfx::Input::*test_key_released_function_type )( unsigned int ) const;
            
            Input_exposer.def( 
                "test_key_released"
                , test_key_released_function_type( &::xfx::Input::TestKeyReleased )
                , ( bp::arg("key") ) );
        
        }
        { //::xfx::Input::TestKeyReleased
        
            typedef bool ( ::xfx::Input::*test_key_released_function_type )( char const * ) const;
            
            Input_exposer.def( 
                "test_key_released"
                , test_key_released_function_type( &::xfx::Input::TestKeyReleased )
                , ( bp::arg("key") ) );
        
        }
        { //property "use_key_mapping"[fget=::xfx::Input::GetUseKeyMapping, fset=::xfx::Input::SetUseKeyMapping]
        
            typedef bool const & ( ::xfx::Input::*fget )(  ) const;
            typedef void ( ::xfx::Input::*fset )( bool const & ) ;
            
            Input_exposer.add_property( 
                "use_key_mapping"
                , bp::make_function( 
                      fget( &::xfx::Input::GetUseKeyMapping )
                    , bp::return_value_policy< bp::copy_const_reference >() ) 
                , fset( &::xfx::Input::SetUseKeyMapping )
                , "get\\set property, built on top of \"bool const & xfx::Input::GetUseKeyMapping() const [member function]\" and \"void xfx::Input::SetUseKeyMapping(bool const & use) [member function]\"" );
        
        }
        { //property "cursor_pos"[fget=::xfx::Input::GetCursorPos]
        
            typedef ::xfx::Vec2 ( ::xfx::Input::*fget )(  ) const;
            
            Input_exposer.add_property( 
                "cursor_pos"
                , fget( &::xfx::Input::GetCursorPos )
                , "get property, built on top of \"xfx::Vec2 xfx::Input::GetCursorPos() const [member function]\"" );
        
        }
        bp::register_ptr_to_python< boost::shared_ptr< xfx::Input const > >( );
        bp::implicitly_convertible< boost::shared_ptr< xfx::Input >, boost::shared_ptr< xfx::Input const > >( );
    }

}