├── .gitignore
├── .nxxm
    ├── deps
    └── opts.wasm-cxx17
├── LICENSE
├── README.md
├── js
    └── bind.hpp
└── test
    ├── CMakeLists.txt
    ├── bind.html
    └── example.html


/.gitignore:
--------------------------------------------------------------------------------
1 | /build
2 | *.swo
3 | *.swp
4 | *.swn
5 | 


--------------------------------------------------------------------------------
/.nxxm/deps:
--------------------------------------------------------------------------------
1 | {
2 |   "cpp-pre/type_traits" : { "@" : "v2.0.0" },
3 |   "platform" : [ "Boost::+boost" ]
4 | }
5 | 


--------------------------------------------------------------------------------
/.nxxm/opts.wasm-cxx17:
--------------------------------------------------------------------------------
1 | set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --bind -s NO_EXIT_RUNTIME=1 ")
2 | set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} --bind -s NO_EXIT_RUNTIME=1")
3 | add_definitions(-g4) # Generates emscripten C++ sourcemaps
4 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2017 Damien Buhl alias daminetreg (damien.buhl@lecbna.org)
 2 | 
 3 | Boost Software License - Version 1.0 - August 17th, 2003
 4 | 
 5 | Permission is hereby granted, free of charge, to any person or organization
 6 | obtaining a copy of the software and accompanying documentation covered by
 7 | this license (the "Software") to use, reproduce, display, distribute,
 8 | execute, and transmit the Software, and to prepare derivative works of the
 9 | Software, and to permit third-parties to whom the Software is furnished to
10 | do so, all subject to the following:
11 | 
12 | The copyright notices in the Software and this entire statement, including
13 | the above license grant, this restriction and the following disclaimer,
14 | must be included in all copies of the Software, in whole or in part, and
15 | all derivative works of the Software, unless such copies or derivative
16 | works are solely in the form of machine-executable object code generated by
17 | a source language processor.
18 | 
19 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 | FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
22 | SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
23 | FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
24 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
25 | DEALINGS IN THE SOFTWARE.
26 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # js::bind
 2 | `js::bind` makes any C++ function, member function or lambda as a Javascript callable callback for [Emscripten](http:://www.emscripten.org/).
 3 | 
 4 | ## Easy to use
 5 | It's header only. You can set-it-up in 0-time with : [`nxxm .`](https://nxxm.github.io/), add this to `.nxxm/deps`
 6 | 
 7 | ```
 8 | {
 9 |   "nxxm/js-bind" : { "@" : "v0.0.3" } 
10 | }
11 | ```
12 | 
13 | * [Simple Example in Browser](https://daminetreg.github.io/js-bind/example.html) : [src: ./test/example.html](./test/example.html)
14 | * [HTTP Request Example](https://daminetreg.github.io/js-bind/bind.html) : [src: ./test/bind.html](./test/bind.html)
15 | 
16 | ```cpp
17 | 
18 |   using namespace std;
19 |   using namespace std::placeholders;
20 |   using emscripten::val;
21 | 
22 |   auto clickme_btn = val::global("document").call<val>("getElementById", "clickme_btn"s);
23 | 
24 |   auto onclick = [](val event){ 
25 |     std::cout << "hello world ! " << std::endl; 
26 |   };
27 | 
28 |   clickme_btn.set("onclick", js::bind(onclick, _1));
29 | ```
30 | 
31 | ## License
32 | Please give copyright notice for this project : [Boost Software License](./LICENSE).
33 | 
34 | ```
35 | Copyright (c) 2017 Damien Buhl alias daminetreg (damien.buhl@lecbna.org)
36 | ```
37 | 
38 |  * [Damien Buhl alias daminetreg](mailto:damien.buhl@lecbna.org)
39 | 


--------------------------------------------------------------------------------
/js/bind.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef JS_BIND_HPP
  2 | #define JS_BIND_HPP
  3 | 
  4 | #include <utility>
  5 | #include <functional>
  6 | 
  7 | #include <emscripten/bind.h>
  8 | #include <emscripten/val.h>
  9 | 
 10 | #include <boost/preprocessor/repetition/repeat.hpp>
 11 | #include <boost/preprocessor/punctuation/comma_if.hpp>
 12 | #include <boost/preprocessor/stringize.hpp>
 13 | 
 14 | #include <pre/type_traits/function_traits.hpp>
 15 | 
 16 | #ifndef JS_BIND_MAX_ARITY
 17 |   /**
 18 |    * \brief JS_BIND_MAX_ARITY Defines how many arguments the javascript
 19 |    *        exported C++  std::function can have. 
 20 |    *        It defaults to 16, simply override it if you need more.
 21 |    */
 22 |   #define JS_BIND_MAX_ARITY 16
 23 | #endif
 24 | 
 25 | #define JS_BIND_DETAIL_ARGS_EACH(z, n, unused)                                 \
 26 |   BOOST_PP_COMMA_IF(n) val 
 27 | 
 28 | #define JS_BIND_DETAIL_ARGS(COUNT)                                             \
 29 |   BOOST_PP_REPEAT(COUNT, JS_BIND_DETAIL_ARGS_EACH, unused)
 30 | 
 31 | #define JS_BIND_DETAIL_EACH(z, n, return_type)                                 \
 32 |   emscripten::class_<                                                          \
 33 |     std::function<                                                             \
 34 |       return_type(JS_BIND_DETAIL_ARGS(n))                                      \
 35 |     >                                                                          \
 36 |   >(BOOST_PP_STRINGIZE(return_type) BOOST_PP_STRINGIZE(n) "ArgsFunctor")       \
 37 |     .constructor<>()                                                           \
 38 |     .function("opcall", &std::function<                                        \
 39 |       return_type(JS_BIND_DETAIL_ARGS(n))                                      \
 40 |     >::operator());                                                            \
 41 | 
 42 | 
 43 | 
 44 | 
 45 | #define JS_BIND_DETAIL_GENERATE_BINDINGS()                                     \
 46 |   BOOST_PP_REPEAT(JS_BIND_MAX_ARITY, JS_BIND_DETAIL_EACH, void)                \
 47 |   BOOST_PP_REPEAT(JS_BIND_MAX_ARITY, JS_BIND_DETAIL_EACH, val)                 \
 48 | 
 49 | 
 50 | #define JS_BIND_FUNCTION_TYPES_EACH(z, n, return_type)                         \
 51 |   template<>                                                                   \
 52 |   struct functor_t<std::is_same<return_type, void>::value, n> {                \
 53 |     typedef ::std::function<                                                   \
 54 |       return_type(JS_BIND_DETAIL_ARGS(n))                                      \
 55 |     > type;                                                                    \
 56 |   };                                                                           \
 57 | 
 58 | #define JS_BIND_FUNCTION_TYPES()                                               \
 59 |   BOOST_PP_REPEAT(JS_BIND_MAX_ARITY, JS_BIND_FUNCTION_TYPES_EACH, void)        \
 60 |   BOOST_PP_REPEAT(JS_BIND_MAX_ARITY, JS_BIND_FUNCTION_TYPES_EACH, val)         \
 61 | 
 62 | 
 63 | #define JS_BIND_DETAIL_FWD(...) ::std::forward<decltype(__VA_ARGS__)>(__VA_ARGS__)
 64 | 
 65 | namespace js {
 66 | 
 67 |   /**
 68 |    * \brief Equivalent of [std::bind](http://en.cppreference.com/w/cpp/utility/functional/bind) returning a javascript functor.
 69 |    * \param f The lambda, function, member function to bind
 70 |    * \param args 
 71 |    * \return An emscripten::val representing a javascript functor with it's 
 72 |    *         this-scope bound correctly. It can be called from js or c++ with 
 73 |    *         the call operator ( *i.e.* `operator()` ).
 74 |    *         
 75 |    */
 76 |   template< class F, class... Args >
 77 |   emscripten::val bind( F&& f, Args&&... args );
 78 | 
 79 | 
 80 |   namespace detail {
 81 |     template<typename... Args> struct placeholders_count;
 82 |    
 83 |     template<>
 84 |     struct placeholders_count<> {
 85 |       static constexpr size_t value = 0;
 86 |     };
 87 |    
 88 |     template <class T>
 89 |     struct one_if_placeholder {
 90 |       static constexpr size_t value = 
 91 |         (std::is_placeholder<typename std::decay<T>::type>::value) ? 1 : 0;
 92 |     };
 93 |    
 94 |     template<typename Arg, typename... Args>
 95 |     struct placeholders_count<Arg, Args...> {
 96 |       static constexpr size_t value = 
 97 |         one_if_placeholder<Arg>::value + placeholders_count<Args...>::value;
 98 |     }; 
 99 |   }
100 | 
101 |   using emscripten::val;
102 | 
103 |   template<const bool returns_void, const size_t arity>
104 |   struct functor_t;
105 | 
106 |   JS_BIND_FUNCTION_TYPES();
107 | 
108 |   EMSCRIPTEN_BINDINGS(jsbindhpp) {
109 |     JS_BIND_DETAIL_GENERATE_BINDINGS()
110 |   }
111 |  
112 |   template< class F, class... Args >
113 |   emscripten::val bind( F&& f, Args&&... args ) {
114 |     using emscripten::val;
115 |     using pre::type_traits::function_traits;
116 | 
117 |     using result_type = typename function_traits<std::decay_t<F>>::result_type;
118 |     auto bind_result = std::bind( std::forward<decltype(f)>(f), JS_BIND_DETAIL_FWD(args)... );
119 | 
120 |       using callback_t = typename functor_t<
121 |         std::is_same< result_type, void>::value,
122 |         detail::placeholders_count<Args...>::value
123 |       >::type;
124 | 
125 |       callback_t functor = bind_result;
126 | 
127 |       // We ensure the correct object will always be bound to the this of the function
128 |       auto functor_adapter = val(functor)["opcall"].call<val>("bind", val(functor)); 
129 |       return functor_adapter;
130 |     }
131 | 
132 | }
133 | 
134 | #endif // JS_BIND_HPP
135 | 


--------------------------------------------------------------------------------
/test/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | add_definitions(-std=c++14)
 2 | 
 3 | if (CMAKE_BUILD_TYPE MATCHES Debug)
 4 |   add_definitions(-g4) # Generates emscripten C++ sourcemaps
 5 | endif()
 6 | 
 7 | # bind
 8 | add_executable(bind bind.cpp)
 9 | set_target_properties(bind PROPERTIES SUFFIX ".html" LINK_FLAGS " --bind -s  NO_EXIT_RUNTIME=1 ")
10 | target_link_libraries(bind cpp-js::js-bind)
11 | 
12 | # example
13 | add_executable(example example.cpp)
14 | set_target_properties(example PROPERTIES SUFFIX ".html" LINK_FLAGS " --bind -s  NO_EXIT_RUNTIME=1 ")
15 | target_link_libraries(example cpp-js::js-bind)
16 | 


--------------------------------------------------------------------------------
/test/bind.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en_US">
 3 | <head>
 4 |   <meta charset="utf-8">
 5 | 
 6 |   <script type="text/c++">
 7 |     #include <iostream>
 8 |     #include <sstream>
 9 |     #include <functional>
10 |     #include <memory>
11 | 
12 |     #include <js/bind.hpp>
13 | 
14 |     using namespace std::placeholders;
15 |     using namespace std::string_literals;
16 |     using emscripten::val;
17 | 
18 |     class MiniXhr : public std::enable_shared_from_this<MiniXhr> {
19 |       using val = emscripten::val;
20 |       using url_t = std::string;
21 | 
22 |       public:
23 | 
24 |         void set_url(const url_t& url) { url_ = url; }
25 | 
26 |         void GET();
27 | 
28 |         /**
29 |          *
30 |          * The member function to be called from javascript.
31 |          */
32 |         void on_readystate(val event) {
33 |           std::cout << "ready " << std::endl;
34 |           std::cout << "xxhr:: " 
35 |               << event["type"].as<std::string>() << ". "
36 |               << xhr["readyState"].as<size_t>() << " - " << url_ << " :: "
37 |               << xhr["status"].as<size_t>() << ": " 
38 |               << xhr["statusText"].as<std::string>() << std::endl;
39 |         }
40 | 
41 |       private:
42 |         url_t url_;
43 |         val xhr = val::global("XMLHttpRequest").new_();
44 |     };
45 |        
46 | 
47 |     void MiniXhr::GET() { 
48 |      
49 |       auto callback = js::bind(&MiniXhr::on_readystate, shared_from_this(), std::placeholders::_1);
50 |       xhr.set("onreadystatechange", callback);
51 | 
52 |       auto lamb = [&](val e) { 
53 |         std::cout << "Im a lambda to handle event : " << e["type"].as<std::string>() << std::endl; 
54 |         
55 |         auto event_text = val::global("document").call<val>("getElementById", "event_text"s);
56 | 
57 | 
58 |         std::stringstream ss;
59 |         ss << xhr["readyState"].as<size_t>() << " - " << url_
60 |           << " :: " << xhr["status"].as<size_t>() << ": "
61 |           << xhr["statusText"].as<std::string>() 
62 |           << std::endl;
63 | 
64 |         event_text.set("innerHTML", "Handling event : "s + ss.str());
65 |       };
66 | 
67 |       xhr.set("onreadystatechange", js::bind(lamb, std::placeholders::_1));
68 |      
69 |       xhr.call<val>("open", std::string("GET"), url_, true);
70 |       xhr.call<val>("send");
71 |     }
72 | 
73 | 
74 |     int main(int argc, char** argv) {
75 |       
76 |       auto clickme_btn = val::global("document").call<val>("getElementById", "clickme_btn"s);
77 | 
78 |       auto onclick = [](val event){ 
79 |         std::cout << "Downloading js/bind.hpp! " << std::endl; 
80 |         auto x = std::make_shared<MiniXhr>(); //shared_ptr needed for callback to work after main exit, due to NO_EXIT_RUNTIME.
81 |         x->set_url("js/bind.hpp");
82 |         x->GET();
83 |       };
84 | 
85 |       clickme_btn.set("onclick", js::bind(onclick, _1));
86 | 
87 | 
88 |       return 0;
89 |     }
90 |  </script> 
91 | </head>
92 | <body>
93 |   <h1>Download some file</h1>
94 |   <button id="clickme_btn">Download</button>
95 |   <span id="event_text"></span>
96 | </body>
97 | </html>
98 | 


--------------------------------------------------------------------------------
/test/example.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en_US">
 3 | <head>
 4 |   <meta charset="utf-8">
 5 | 
 6 |   <script type="text/c++">
 7 | 
 8 |     #include <iostream>
 9 |     #include <js/bind.hpp>
10 | 
11 |     using namespace std::placeholders;
12 |     using namespace std::string_literals;
13 |     using emscripten::val;
14 | 
15 |     int main() {
16 |       auto clickme_btn = val::global("document").call<val>("getElementById", "clickme_btn"s);
17 | 
18 |       auto onclick = [](val event){ 
19 |         std::cout << "hello world ! " << std::endl; 
20 |       };
21 | 
22 |       clickme_btn.set("onclick", js::bind(onclick, _1));
23 |     }
24 | 
25 |  </script> 
26 | </head>
27 | <body>
28 |   <h1>Call C++ back</h1>
29 |   <button id="clickme_btn">Click me</button>
30 | </body>
31 | </html>
32 | 


--------------------------------------------------------------------------------