Merge pull request #55 from SylvainCorlay/update-xwidgets

Update xwidgets

Author: SylvainCorlay

.appveyor.yml

@@ -29,7 +29,7 @@ install:
   - conda update -q conda
   - conda info -a
   # Install host dependencies
-  - conda install xeus=0.21.1 cppzmq=4.3.0 xproperty=0.8.1 xwidgets=0.19.0 -c conda-forge
+  - conda install xeus=0.23.3 cppzmq=4.3.0 xproperty=0.10.1 xwidgets=0.20.0 -c conda-forge
   # Install build dependencies
   - conda install gtest cmake -c conda-forge
   - cmake -G "NMake Makefiles" -D CMAKE_INSTALL_PREFIX=%MINICONDA%\\LIBRARY -DBUILD_TESTS=ON .

.travis.yml

@@ -18,7 +18,7 @@ install:
     - conda config --set always_yes yes --set changeps1 no
     - conda update -q conda
     # Install host dependencies
-    - conda install xeus=0.21.1 cppzmq=4.3.0 xproperty=0.8.1 xwidgets=0.19.0 -c conda-forge
+    - conda install xeus=0.23.3 cppzmq=4.3.0 xproperty=0.10.1 xwidgets=0.20.0 -c conda-forge
     # Install build dependencies
     - conda install cmake
     - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then

CMakeLists.txt

@@ -74,8 +74,9 @@ message(STATUS "xplot binary version: v${XPLOT_BINARY_VERSION}")
 
 find_package(cppzmq 4.3.0 REQUIRED)
 find_package(xtl 0.6.5 REQUIRED)
-find_package(xeus 0.21.1 REQUIRED)
-find_package(xwidgets 0.19.0 REQUIRED)
+find_package(xeus 0.23.3 REQUIRED)
+find_package(xwidgets 0.20.0 REQUIRED)
+find_package(xproperty 0.10.1 REQUIRED)
 
 # Source files
 # ============

README.md

@@ -79,7 +79,7 @@ All the dependencies of xplot are available for the conda package manager.
 
 | `xplot` | `xwidgets`  |  `xeus`         |
 |---------|-------------|-----------------|
-|  master |   ~0.19.0   |  >=0.21.1,<0.22 |
+|  master |   ~0.20.0   |  >=0.23.3,<0.24 |
 |  0.14.0 |   ~0.19.0   |  >=0.21.1,<0.22 |
 |  0.13.0 |   ~0.18.0   |  >=0.20.0,<0.21 |
 |  0.12.0 |   ~0.17.0   |  >=0.19.1,<0.20 |

environment.yml

@@ -4,6 +4,6 @@ channels:
   - conda-forge
 dependencies:
   - xplot=0.14.0
-  - xeus-cling=0.7.1
+  - xeus-cling=0.8.1
   - bqplot=0.11.5
   - widgetsnbextension >=3.0.0

include/xplot/xaxes.hpp

@@ -13,6 +13,8 @@
 #include <utility>
 #include <vector>
 
+#include "nlohmann/json.hpp"
+
 #include "xtl/xoptional.hpp"
 
 #include "xwidgets/xeither.hpp"
@@ -21,6 +23,8 @@
 #include "xscales.hpp"
 #include "xinteracts.hpp"
 
+namespace nl = nlohmann;
+
 namespace xpl
 {
     /********************
@@ -38,8 +42,8 @@ namespace xpl
         using scale_type = xw::xholder<xscale>;
         using tick_values_type = std::vector<double>;
 
-        void serialize_state(xeus::xjson&, xeus::buffer_sequence&) const;
-        void apply_patch(const xeus::xjson&, const xeus::buffer_sequence&);
+        void serialize_state(nl::json&, xeus::buffer_sequence&) const;
+        void apply_patch(const nl::json&, const xeus::buffer_sequence&);
 
         XPROPERTY(std::string, derived_type, orientation, "horizontal", XEITHER("horizontal", "vertical"));
         XPROPERTY(xtl::xoptional<std::string>, derived_type, side, xtl::missing<std::string>(), XEITHER_OPTIONAL("bottom", "top", "left", "right"));
@@ -48,8 +52,8 @@ namespace xpl
         XPROPERTY(xtl::xoptional<std::string>, derived_type, tick_format);
         XPROPERTY(scale_type, derived_type, scale);
         XPROPERTY(xtl::xoptional<int>, derived_type, num_ticks);
-        XPROPERTY(::xeus::xjson, derived_type, tick_values, xeus::xjson::array());
-        XPROPERTY(::xeus::xjson, derived_type, offset, ::xeus::xjson::object());
+        XPROPERTY(::nl::json, derived_type, tick_values, nl::json::array());
+        XPROPERTY(::nl::json, derived_type, offset, ::nl::json::object());
         XPROPERTY(std::string, derived_type, label_location, "middle", XEITHER("middle", "start", "end"));
         XPROPERTY(xtl::xoptional<color_type>, derived_type, label_color);
         XPROPERTY(xtl::xoptional<color_type>, derived_type, grid_color);
@@ -77,8 +81,6 @@ namespace xpl
 
     using axis = xw::xmaterialize<xaxis>;
 
-    using axis_generator = xw::xgenerator<xaxis>;
-
     template <class T, class R = void>
     struct enable_xaxis
     {
@@ -100,8 +102,8 @@ namespace xpl
         using base_type = xaxis<D>;
         using derived_type = D;
 
-        void serialize_state(xeus::xjson&, xeus::buffer_sequence&) const;
-        void apply_patch(const xeus::xjson&, const xeus::buffer_sequence&);
+        void serialize_state(nl::json&, xeus::buffer_sequence&) const;
+        void apply_patch(const nl::json&, const xeus::buffer_sequence&);
 
     protected:
 
@@ -123,14 +125,12 @@ namespace xpl
 
     using color_axis = xw::xmaterialize<xcolor_axis>;
 
-    using color_axis_generator = xw::xgenerator<xcolor_axis>;
-
     /***********************
      * axis implementation *
      ***********************/
 
     template <class D>
-    inline void xaxis<D>::apply_patch(const xeus::xjson& patch, const xeus::buffer_sequence& buffers)
+    inline void xaxis<D>::apply_patch(const nl::json& patch, const xeus::buffer_sequence& buffers)
     {
         using xw::set_property_from_patch;
         base_type::apply_patch(patch, buffers);
@@ -153,26 +153,26 @@ namespace xpl
     }
 
     template <class D>
-    inline void xaxis<D>::serialize_state(xeus::xjson& state, xeus::buffer_sequence& buffers) const
+    inline void xaxis<D>::serialize_state(nl::json& state, xeus::buffer_sequence& buffers) const
     {
-        using xw::set_patch_from_property;
+        using xw::xwidgets_serialize;
         base_type::serialize_state(state, buffers);
 
-        set_patch_from_property(orientation, state, buffers);
-        set_patch_from_property(side, state, buffers);
-        set_patch_from_property(label, state, buffers);
-        set_patch_from_property(tick_format, state, buffers);
-        set_patch_from_property(scale, state, buffers);
-        set_patch_from_property(num_ticks, state, buffers);
-        set_patch_from_property(tick_values, state, buffers);
-        set_patch_from_property(offset, state, buffers);
-        set_patch_from_property(label_location, state, buffers);
-        set_patch_from_property(label_color, state, buffers);
-        set_patch_from_property(grid_lines, state, buffers);
-        set_patch_from_property(grid_color, state, buffers);
-        set_patch_from_property(color, state, buffers);
-        set_patch_from_property(label_offset, state, buffers);
-        set_patch_from_property(visible, state, buffers);
+        xwidgets_serialize(orientation, state["orientation"], buffers);
+        xwidgets_serialize(side, state["side"], buffers);
+        xwidgets_serialize(label, state["label"], buffers);
+        xwidgets_serialize(tick_format, state["tick_format"], buffers);
+        // xwidgets_serialize(scale, state["scale"], buffers);
+        xwidgets_serialize(num_ticks, state["num_ticks"], buffers);
+        xwidgets_serialize(tick_values, state["tick_values"], buffers);
+        xwidgets_serialize(offset, state["offset"], buffers);
+        xwidgets_serialize(label_location, state["label_location"], buffers);
+        xwidgets_serialize(label_color, state["label_color"], buffers);
+        xwidgets_serialize(grid_lines, state["grid_lines"], buffers);
+        xwidgets_serialize(grid_color, state["grid_color"], buffers);
+        xwidgets_serialize(color, state["color"], buffers);
+        xwidgets_serialize(label_offset, state["label_offset"], buffers);
+        xwidgets_serialize(visible, state["visible"], buffers);
     }
 
     template <class D>
@@ -217,16 +217,16 @@ namespace xpl
      ******************************/
 
     template <class D>
-    inline void xcolor_axis<D>::apply_patch(const xeus::xjson& patch, const xeus::buffer_sequence& buffers)
+    inline void xcolor_axis<D>::apply_patch(const nl::json& patch, const xeus::buffer_sequence& buffers)
     {
         using xw::set_property_from_patch;
         base_type::apply_patch(patch, buffers);
     }
 
     template <class D>
-    inline void xcolor_axis<D>::serialize_state(xeus::xjson& state, xeus::buffer_sequence& buffers) const
+    inline void xcolor_axis<D>::serialize_state(nl::json& state, xeus::buffer_sequence& buffers) const
     {
-        using xw::set_patch_from_property;
+        using xw::xwidgets_serialize;
         base_type::serialize_state(state, buffers);
     }
 
@@ -269,13 +269,9 @@ namespace xpl
 #ifndef _WIN32
     extern template class xw::xmaterialize<xpl::xaxis>;
     extern template class xw::xtransport<xw::xmaterialize<xpl::xaxis>>;
-    extern template class xw::xgenerator<xpl::xaxis>;
-    extern template class xw::xtransport<xw::xgenerator<xpl::xaxis>>;
 
     extern template class xw::xmaterialize<xpl::xcolor_axis>;
     extern template class xw::xtransport<xw::xmaterialize<xpl::xcolor_axis>>;
-    extern template class xw::xgenerator<xpl::xcolor_axis>;
-    extern template class xw::xtransport<xw::xgenerator<xpl::xcolor_axis>>;
 #endif
 
 #endif

include/xplot/xboxed_container.hpp

@@ -9,10 +9,17 @@
 #ifndef XBOXED_CONTAINER_HPP
 #define XBOXED_CONTAINER_HPP
 
+#include <algorithm>
 #include <string>
+#include <utility>
+#include <vector>
+
+#include "nlohmann/json.hpp"
 
 #include "xeus/xjson.hpp"
 
+namespace nl = nlohmann;
+
 namespace xpl
 {
     /********************************
@@ -56,9 +63,9 @@ namespace xpl
     };
 
     template <class C>
-    void to_json(xeus::xjson& j, const xboxed_container<C>& o);
+    void to_json(nl::json& j, const xboxed_container<C>& o);
     template <class C>
-    void from_json(const xeus::xjson& j, xboxed_container<C>& o);
+    void from_json(const nl::json& j, xboxed_container<C>& o);
 
     template <class T>
     std::string type_to_string() noexcept;
@@ -122,15 +129,15 @@ namespace xpl
     }
 
     template <class C>
-    inline void to_json(xeus::xjson& j, const xboxed_container<C>& o)
+    inline void to_json(nl::json& j, const xboxed_container<C>& o)
     {
         using container_type = typename xboxed_container<C>::container_type;
         j["values"] = container_type(o);
         j["type"] = type_to_string<typename container_type::value_type>();
     }
 
     template <class C>
-    inline void from_json(const xeus::xjson& j, xboxed_container<C>& o)
+    inline void from_json(const nl::json& j, xboxed_container<C>& o)
     {
         using container_type = typename xboxed_container<C>::container_type;
         container_type& values = o;

include/xplot/xfigure.hpp

@@ -13,6 +13,10 @@
 #include <vector>
 #include <utility>
 
+#include "nlohmann/json.hpp"
+
+#include "xproperty/xjson.hpp" 
+
 #include "xwidgets/xeither.hpp"
 #include "xwidgets/xwidget.hpp"
 
@@ -21,6 +25,8 @@
 #include "xplot_config.hpp"
 #include "xscales.hpp"
 
+namespace nl = nlohmann;
+
 namespace xpl
 {
     /***********************
@@ -40,20 +46,20 @@ namespace xpl
         using scales_type = xw::xholder<xscale>;
         using interaction_type = xw::xholder<xinteraction>;
 
-        void serialize_state(xeus::xjson&, xeus::buffer_sequence&) const;
-        void apply_patch(const xeus::xjson&, const xeus::buffer_sequence&);
+        void serialize_state(nl::json&, xeus::buffer_sequence&) const;
+        void apply_patch(const nl::json&, const xeus::buffer_sequence&);
 
         XPROPERTY(std::string, derived_type, title);
         XPROPERTY(axes_type, derived_type, axes);
         XPROPERTY(marks_type, derived_type, marks);
         XPROPERTY(xtl::xoptional<interaction_type>, derived_type, interaction);
         XPROPERTY(scales_type, derived_type, scale_x);
         XPROPERTY(scales_type, derived_type, scale_y);
-        XPROPERTY(::xeus::xjson, derived_type, title_style);
-        XPROPERTY(::xeus::xjson, derived_type, background_style);
+        XPROPERTY(::nl::json, derived_type, title_style);
+        XPROPERTY(::nl::json, derived_type, background_style);
         XPROPERTY(double, derived_type, min_aspect_ratio, 1.);
         XPROPERTY(double, derived_type, max_aspect_ratio, 6.);
-        XPROPERTY(::xeus::xjson, derived_type, fig_margin, xeus::xjson({
+        XPROPERTY(::nl::json, derived_type, fig_margin, nl::json({
            {"top", 60}, {"bottom", 60}, {"left", 60}, {"right", 60}
         }));
         XPROPERTY(double, derived_type, padding_x, 0.);
@@ -104,8 +110,6 @@ namespace xpl
 
     using figure = xw::xmaterialize<xfigure>;
 
-    using figure_generator = xw::xgenerator<xfigure>;
-
     template <class T, class R = void>
     struct enable_xfigure
     {
@@ -120,7 +124,7 @@ namespace xpl
      **************************/
 
     template <class D>
-    inline void xfigure<D>::apply_patch(const xeus::xjson& patch, const xeus::buffer_sequence& buffers)
+    inline void xfigure<D>::apply_patch(const nl::json& patch, const xeus::buffer_sequence& buffers)
     {
         using xw::set_property_from_patch;
         base_type::apply_patch(patch, buffers);
@@ -143,26 +147,26 @@ namespace xpl
     }
 
     template <class D>
-    inline void xfigure<D>::serialize_state(xeus::xjson& state, xeus::buffer_sequence& buffers) const
+    inline void xfigure<D>::serialize_state(nl::json& state, xeus::buffer_sequence& buffers) const
     {
-        using xw::set_patch_from_property;
+        using xw::xwidgets_serialize;
         base_type::serialize_state(state, buffers);
 
-        set_patch_from_property(title, state, buffers);
-        set_patch_from_property(axes, state, buffers);
-        set_patch_from_property(marks, state, buffers);
-        set_patch_from_property(interaction, state, buffers);
-        set_patch_from_property(scale_x, state, buffers);
-        set_patch_from_property(scale_y, state, buffers);
-        set_patch_from_property(title_style, state, buffers);
-        set_patch_from_property(background_style, state, buffers);
-        set_patch_from_property(min_aspect_ratio, state, buffers);
-        set_patch_from_property(max_aspect_ratio, state, buffers);
-        set_patch_from_property(fig_margin, state, buffers);
-        set_patch_from_property(padding_x, state, buffers);
-        set_patch_from_property(padding_y, state, buffers);
-        set_patch_from_property(legend_location, state, buffers);
-        set_patch_from_property(animation_duration, state, buffers);
+        xwidgets_serialize(title, state["title"], buffers);
+        xwidgets_serialize(axes, state["axes"], buffers);
+        xwidgets_serialize(marks, state["marks"], buffers);
+        xwidgets_serialize(interaction, state["interaction"], buffers);
+        xwidgets_serialize(scale_x, state["scale_x"], buffers);
+        xwidgets_serialize(scale_y, state["scale_y"], buffers);
+        xwidgets_serialize(title_style, state["title_style"], buffers);
+        xwidgets_serialize(background_style, state["background_style"], buffers);
+        xwidgets_serialize(min_aspect_ratio, state["min_aspect_ratio"], buffers);
+        xwidgets_serialize(max_aspect_ratio, state["max_aspect_ratio"], buffers);
+        xwidgets_serialize(fig_margin, state["fig_margin"], buffers);
+        xwidgets_serialize(padding_x, state["padding_x"], buffers);
+        xwidgets_serialize(padding_y, state["padding_y"], buffers);
+        xwidgets_serialize(legend_location, state["legend_location"], buffers);
+        xwidgets_serialize(animation_duration, state["animation_duration"], buffers);
     }
 
     template <class D>
@@ -293,20 +297,20 @@ namespace xpl
     template <class D>
     inline void xfigure<D>::send_marks_patch() const
     {
-        using xw::set_patch_from_property;
-        xeus::xjson state;
+        using xw::xwidgets_serialize;
+        nl::json state;
         xeus::buffer_sequence buffers;
-        set_patch_from_property(marks, state, buffers);
+        xwidgets_serialize(marks, state["marks"], buffers);
         this->send_patch(std::move(state), std::move(buffers));
     }
 
     template <class D>
     inline void xfigure<D>::send_axes_patch() const
     {
-        using xw::set_patch_from_property;
-        xeus::xjson state;
+        using xw::xwidgets_serialize;
+        nl::json state;
         xeus::buffer_sequence buffers;
-        set_patch_from_property(axes, state, buffers);
+        xwidgets_serialize(axes, state["axes"], buffers);
         this->send_patch(std::move(state), std::move(buffers));
     }
 }
@@ -319,9 +323,6 @@ namespace xpl
     extern template class xw::xmaterialize<xpl::xfigure>;
     extern template class xw::xtransport<xw::xmaterialize<xpl::xfigure>>;
     extern template xw::xmaterialize<xpl::xfigure>::xmaterialize();
-    extern template class xw::xgenerator<xpl::xfigure>;
-    extern template xw::xgenerator<xpl::xfigure>::xgenerator();
-    extern template class xw::xtransport<xw::xgenerator<xpl::xfigure>>;
 #endif
 
 #endif