hyper-vis 1.0.0.lap34 → 1.0.1

data/lib/hyperloop/vis/network/mixin.rb

@@ -14,7 +14,7 @@ module Hyperloop
               @_dom_node = dom_node
             end
 
-            def data
+            def vis_data
               @_data
             end
 

data/lib/hyperloop/vis/timeline/component.rb

@@ -0,0 +1,16 @@
+module Hyperloop
+  module Vis
+    module Timeline
+      class Component
+        include Hyperloop::Vis::Timeline::Mixin
+        def self.inherited(base)
+          base.class_eval do
+            param items: nil
+            param groups: nil
+            param options: nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hyperloop/vis/timeline/mixin.rb

@@ -0,0 +1,89 @@
+require 'react/component'
+
+module Hyperloop
+  module Vis
+    module Timeline
+      module Mixin
+        def self.included(base)
+          base.include(Hyperloop::Component::Mixin)
+          base.class_eval do
+            param items: nil
+            param groups: nil
+            param options: nil
+
+            def _set_dom_node(dom_node)
+              @_dom_node = dom_node
+            end
+
+            def items
+              @_items
+            end
+
+            def groups
+              @_groups
+            end
+
+            def document
+              `window.document`
+            end
+
+            def options
+              @_options
+            end
+
+            def automatic_refresh
+              true
+            end
+            
+            def self.automatic_refresh(value)
+              define_method(:automatic_refresh) do
+                value
+              end
+            end
+            
+            def self.render_with_dom_node(tag = 'DIV', &block)
+              render do
+                @_vis_render_block = block
+                @_items = params.items
+                @_groups = params.groups
+                @_options = params.options
+                send(tag, ref: method(:_set_dom_node).to_proc)
+              end
+            end
+
+            def should_component_update?
+              `false`
+            end
+
+            after_mount do
+              if @_dom_node && @_vis_render_block
+                instance_exec(@_dom_node, @_items, @_groups, @_options, &@_vis_render_block)
+              end
+            end
+
+            before_receive_props do |new_props|
+              if automatic_refresh && @_dom_node && @_vis_render_block
+                changed = false
+                if new_props[:items] != @_items
+                  @_items = new_props[:items]
+                  changed = true
+                end
+                if new_props[:groups] != @_groups
+                  @_items = new_props[:groups]
+                  changed = true
+                end
+                if new_props[:options] != @_options
+                  @_options = new_props[:options]
+                  changed = true
+                end
+                if changed
+                  instance_exec(@_dom_node, @_items, @_groups, @_options, &@_vis_render_block)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hyperloop/vis/version.rb

@@ -1,5 +1,5 @@
 module Hyperloop
   module Vis
-    VERSION = '1.0.0.lap34'
+    VERSION = '1.0.1'
   end
 end

data/lib/vis.rb

@@ -6,4 +6,7 @@ require 'vis/event_support'
 require 'vis/data_common'
 require 'vis/data_set'
 require 'vis/data_view'
-require 'vis/network'
+require 'vis/graph2d'
+require 'vis/graph3d'
+require 'vis/network'
+require 'vis/timeline'

data/lib/vis/data_common.rb

@@ -19,5 +19,51 @@ module Vis
     def get_ids(options)
       @native.JS.getIds(options_to_native(options))
     end
+
+    # events
+    
+    def off(event, event_handler_id)
+      event = lower_camelize(event)
+      handler = @event_handlers[event][event_handler_id]
+      `self["native"].off(event, handler)`
+      @event_handlers[event].delete(event_handler_id)
+    end
+
+    def on(event, &block)
+      event = lower_camelize(event)
+      @event_handlers[event] = {} unless @event_handlers[event]
+      event_handler_id = `Math.random().toString(36).substring(6)`
+      handler = %x{
+        function(event, properties, sender_id) {
+          return block.$call(Opal.Hash.$new(event),Opal.Hash.$new(properties), sender_id);
+        }
+      }
+      @event_handlers[event][event_handler_id] = handler
+      `self["native"].on(event, handler);`
+      event_handler_id
+    end
+    
+    # options
+
+    def options_to_native(options)
+      return unless options
+      new_opts = {}.merge!(options)
+
+      if new_opts.has_key?(:filter)
+        block = new_opts[:filter]
+        if `typeof block === "function"`
+          unless new_opts[:filter].JS[:hyper_wrapped]
+            new_opts[:filter] = %x{
+              function(item) {
+                return #{block.call(`Opal.Hash.$new(item)`)};
+              }
+            }
+            new_opts[:filter].JS[:hyper_wrapped] = true
+          end
+        end
+      end
+      
+      lower_camelize_hash(new_opts).to_n
+    end
   end
 end

data/lib/vis/data_set.rb

@@ -11,6 +11,12 @@ module Vis
     
     attr_reader :event_handlers
 
+    def self.wrap(native)
+      instance = allocate
+      instance.instance_variable_set(:@native, native)
+      instance
+    end
+
     def initialize(*args)
       if args[0] && `Opal.is_a(args[0], Opal.Hash)`
         hash_array = []
@@ -86,6 +92,5 @@ module Vis
       end
       `self["native"].update.apply(self["native"], Opal.to_a(args))`
     end
-
   end
 end

data/lib/vis/graph2d.rb

@@ -0,0 +1,145 @@
+module Vis
+  class Graph2d
+    include Native
+    include Vis::Utilities
+
+    aliases_native %i[
+      addCustomTime
+      destroy
+      fit
+      getCurrentTime
+      getCustomTime
+      isGroupVisible
+      redraw
+      removeCustomTime
+      setCurrentTime
+      setCustomTime
+      setWindow
+    ]
+
+    def initialize(native_container, item_dataset, group_dataset = nil, options = {})
+      native_item_data = item_dataset.to_n
+      if group_dataset.is_a?(Hash) && options == {}
+        options = group_dataset
+        group_dataset = nil
+      end
+      native_options = options_to_native(options)
+      @event_handlers = {}
+      if group_dataset.nil?
+        @native = `new vis.Graph2d(native_container, native_item_data, native_options)`
+      else
+        native_group_data = group_dataset.to_n
+        @native = `new vis.Graph2d(native_container, native_item_data, native_group_data, native_options)`
+      end
+    end
+
+    def off(event, event_handler_id)
+      event = lower_camelize(event)
+      handler = @event_handlers[event][event_handler_id]
+      `self["native"].off(event, handler)`
+      @event_handlers[event].delete(event_handler_id)
+    end
+
+    EVENTS_NO_PARAM = %i[currentTimeTick changed]
+    
+    def on(event, &block)
+      event = lower_camelize(event)
+      @event_handlers[event] = {} unless @event_handlers[event]
+      event_handler_id = `Math.random().toString(36).substring(6)`
+      handler = if EVENTS_NO_PARAM.include?(event)
+        `function() { block.$call(); }`
+      else
+        `function(event_info) { block.$call(Opal.Hash.$new(event_info)); }`
+      end
+      @event_handlers[event][event_handler_id] = handler
+      `self["native"].on(event, handler)`
+      event_handler_id
+    end
+
+    def set_groups(dataset)
+      @native.JS.setGroups(dataset.to_n)
+    end
+    
+    def set_items(dataset)
+      @native.JS.setItems(dataset.to_n)
+    end
+
+    def set_options(options)
+      @native.JS.setOptions(options_to_native(options))
+    end
+
+    def get_data_range
+      res = @native.JS.getDataRange()
+      `Opal.Hash.$new(res)`
+    end
+
+    def get_event_properties(event)
+      res = @native.JS.getEventProperties(event.to_n)
+      `Opal.Hash.$new(res)`
+    end
+    
+    def get_legend(group_id, icon_width, icon_height)
+      res = @native.JS.getLegend(group_id, icon_width, icon_height)
+      `Opal.Hash.$new(res)`
+    end
+
+    def get_window
+      res = @native.JS.getWindow()
+      `Opal.Hash.$new(res)`
+    end
+
+    def move_to(time, options = {})
+      @native.JS.moveTo(time, options_to_native(options))
+    end
+
+    def options_to_native(options)
+      return unless options
+      # options must be duplicated, so callbacks dont get wrapped twice
+      new_opts = {}.merge!(options)
+
+      if new_opts.has_key?(:configure)
+        block = new_opts[:configure]
+        if `typeof block === "function"`
+          unless new_opts[:configure].JS[:hyper_wrapped]
+            new_opts[:configure] = %x{
+              function(option, path) {
+                return block.$call(option, path);
+              }
+            }
+            new_opts[:configure].JS[:hyper_wrapped] = true
+          end
+        end
+      end
+
+      if new_opts.has_key?(:draw_points)
+        block = new_opts[:draw_points]
+        if `typeof block === "function"`
+          unless new_opts[:draw_points].JS[:hyper_wrapped]
+            new_opts[:draw_points] = %x{
+              function(item, group) {
+                return block.$call(Opal.Hash.$new(item), Opal.Hash.$new(group));
+              }
+            }
+            new_opts[:draw_points].JS[:hyper_wrapped] = true
+          end
+        end
+      end
+
+      if new_opts.has_key?(:moment)
+        block = new_opts[:moment]
+        if `typeof block === "function"`
+          unless new_opts[:moment].JS[:hyper_wrapped]
+            new_opts[:moment] = %x{
+              function(native_date) {
+                return block.$call(native_date);
+              }
+            }
+            new_opts[:moment].JS[:hyper_wrapped] = true
+          end
+        end
+      end
+
+      lower_camelize_hash(new_opts).to_n
+    end
+  end
+end

data/lib/vis/graph3d.rb

@@ -0,0 +1,135 @@
+module Vis
+  class Graph3d
+    include Native
+    include Vis::Utilities
+
+    aliases_native %i[
+      animationStart
+      animationStop
+      redraw
+      setSize
+    ]
+
+    def initialize(native_container, dataset, options = {})
+      native_options = options_to_native(options)
+      native_data = dataset.to_n
+      @event_handlers = {}
+      @native = `new vis.Graph3d(native_container, native_data, native_options)`
+    end
+
+    def off(event, event_handler_id)
+      event = lower_camelize(event)
+      handler = @event_handlers[event][event_handler_id]
+      `self["native"].off(event, handler)`
+      @event_handlers[event].delete(event_handler_id)
+    end
+    
+    def on(event, &block)
+      event = lower_camelize(event)
+      @event_handlers[event] = {} unless @event_handlers[event]
+      event_handler_id = `Math.random().toString(36).substring(6)`
+      handler = `function(event_info) { block.$call(Opal.Hash.$new(event_info)); }`
+      @event_handlers[event][event_handler_id] = handler
+      `self["native"].on(event, handler)`
+      event_handler_id
+    end
+
+    def set_data(dataset)
+      native_data = dataset.to_n
+      @native.JS.setData(native_data)
+    end
+
+    def set_options(options)
+      native_options = options_to_native(options)
+      @native.JS.setOptions(native_options)
+    end
+
+    def get_camera_position
+      res = @native.JS.getCameraPosition()
+      `Opal.Hash.$new(res)`
+    end
+
+    def set_camera_position(dis_hor_ver)
+      res = @native.JS.setCameraPosition(dis_hor_ver.to_n)
+      `Opal.Hash.$new(res)`
+    end
+
+    def options_to_native(options)
+      return unless options
+      # options must be duplicated, so callbacks dont get wrapped twice
+      new_opts = {}.merge!(options)
+
+      if new_opts.has_key?(:onclick)
+        block = new_opts[:onclick]
+        if `typeof block === "function"`
+          unless new_opts[:onclick].JS[:hyper_wrapped]
+            new_opts[:onclick] = %x{
+              function(point) {
+                return #{block.call(`Opal.Hash.$new(point)`)};
+              }
+            }
+            new_opts[:onclick].JS[:hyper_wrapped] = true
+          end
+        end
+      end
+
+      if new_opts.has_key?(:tooltip)
+        block = new_opts[:tooltip]
+        if `typeof block === "function"`
+          unless new_opts[:tooltip].JS[:hyper_wrapped]
+            new_opts[:tooltip] = %x{
+              function(item) {
+                return #{block.call(`Opal.Hash.$new(item)`)};
+              }
+            }
+            new_opts[:tooltip].JS[:hyper_wrapped] = true
+          end
+        end
+      end
+
+      if new_opts.has_key?(:x_value_label)
+        block = new_opts[:x_value_label]
+        if `typeof block === "function"`
+          unless new_opts[:x_value_label].JS[:hyper_wrapped]
+            new_opts[:x_value_label] = %x{
+              function(value) {
+                return #{block.call(value)};
+              }
+            }
+            new_opts[:x_value_label].JS[:hyper_wrapped] = true
+          end
+        end
+      end
+
+      if new_opts.has_key?(:y_value_label)
+        block = new_opts[:y_value_label]
+        if `typeof block === "function"`
+          unless new_opts[:y_value_label].JS[:hyper_wrapped]
+            new_opts[:y_value_label] = %x{
+              function(value) {
+                return #{block.call(value)};
+              }
+            }
+            new_opts[:y_value_label].JS[:hyper_wrapped] = true
+          end
+        end
+      end
+
+      if new_opts.has_key?(:z_value_label)
+        block = new_opts[:z_value_label]
+        if `typeof block === "function"`
+          unless new_opts[:z_value_label].JS[:hyper_wrapped]
+            new_opts[:z_value_label] = %x{
+              function(value) {
+                return #{block.call(value)};
+              }
+            }
+            new_opts[:z_value_label].JS[:hyper_wrapped] = true
+          end
+        end
+      end
+
+      lower_camelize_hash(new_opts).to_n
+    end
+  end
+end