atome 0.5.4.1.7 → 0.5.5.6.4

data/lib/atome/renderers/browser/browser.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'atome/renderers/browser/opal_add_on'
-require 'atome/renderers/browser/effect'
-require 'atome/renderers/browser/event'
-require 'atome/renderers/browser/geometry'
-require 'atome/renderers/browser/identity'
-require 'atome/renderers/browser/material'
-require 'atome/renderers/browser/spatial'
-require 'atome/renderers/browser/atome'
-require 'atome/renderers/browser/utility'
-require 'atome/renderers/browser/time'
-require 'atome/renderers/browser/helpers/browser_helper'
-require 'atome/renderers/browser/helpers/animation_helper'
-require 'atome/renderers/browser/helpers/color_helper'
-require 'atome/renderers/browser/helpers/drag_helper'
-require 'atome/renderers/browser/helpers/drop_helper'
-# require 'atome/renderers/browser/helpers/over_helper'
-require 'atome/renderers/browser/helpers/effect_helper'
-require 'atome/renderers/browser/helpers/event_helper'
-require 'atome/renderers/browser/helpers/image_helper'
-require 'atome/renderers/browser/helpers/shadow_helper'
-require 'atome/renderers/browser/helpers/shape_helper'
-require 'atome/renderers/browser/helpers/text_helper'
-require 'atome/renderers/browser/helpers/video_helper'
-require 'atome/renderers/browser/helpers/web_helper'
-
-class Atome
-  attr_accessor :browser_object
-
-  def to_px
-    id_found = real_atome[:id]
-    property_found=property
-    value_get = ''
-    `
-      div = document.getElementById(#{id_found});
-      var style = window.getComputedStyle(div);
-      var original_value = style.getPropertyValue(#{property_found});
-      #{value_get}= parseInt(original_value);
-    `
-    value_get
-  end
-end
-
-def atome_js
-  `atomeJS`
-end

data/lib/atome/renderers/browser/effect.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-generator = Genesis.generator
-
-generator.build_render(:browser_smooth) do |value|
-  format_params = case value
-                  when Array
-                    properties = []
-                    value.each do |param|
-                      properties << "#{param}px"
-                    end
-                    properties.join(' ').to_s
-                  when Integer
-                    "#{value}px"
-                  else
-                    value
-                  end
-  @browser_object.style['border-radius'] = format_params
-end
-
-generator.build_render(:browser_blur) do |value|
-  BrowserHelper.send("browser_blur_#{@browser_type}", @browser_object, value, @atome)
-end

data/lib/atome/renderers/browser/event.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-generator = Genesis.generator
-
-generator.build_render(:browser_touch) do |value, proc|
-  atome_id = @browser_object.attribute(:id)
-   # value.each do |tap_mode, user_proc|
-   #   alert "#{tap_mode} : #{user_proc}\n #{tap_mode.class} : #{user_proc.class}"
-   #   BrowserHelper.send("browser_touch_#{tap_mode}", atome_id,self, user_proc)
-   # end
-  # alert "#{value} : #{proc}\n #{value.class} : #{proc.class}"
-  BrowserHelper.send("browser_touch_#{value}", atome_id,self, proc)
-end
-
-generator.build_render(:browser_over) do |value, proc|
-  BrowserHelper.send("browser_over_#{value}", @browser_object,self, proc)
-end
-
-# generator.build_render(:browser_over) do |options, proc|
-#   # puts "method : #{options}, params : #{options}"
-#   options.each do |method, params|
-#     atome_id = @atome[:id]
-#     BrowserHelper.send("browser_over_#{method}", params, atome_id, self, proc)
-#   end
-# end
-
-
-generator.build_render(:browser_play) do |value, proc|
-  # first we reinit the 'at' event so the condition will be met again
-  # @at_time[:used] = nil
-  @browser_object.currentTime = value if value != true
-  BrowserHelper.send("browser_play_#{@atome[:type]}", value, @browser_object, @atome, self, proc)
-end
-
-generator.build_render(:browser_time) do |value = nil, _proc|
-  if value
-    @browser_object.currentTime = value
-  else
-    @browser_object.currentTime
-  end
-end
-
-generator.build_render(:browser_pause) do |_value, proc|
-  instance_exec(@browser_object.currentTime, &proc) if proc.is_a?(Proc)
-  @browser_object.pause
-end
-
-generator.build_render(:on) do |value, proc|
-  @browser_object.on(value) do |e|
-    instance_exec(e, &proc) if proc.is_a?(Proc)
-  end
-end
-
-generator.build_render(:fullscreen) do |_value, _proc|
-  atome_id = atome[:id]
-  atome_js.JS.fullscreen(atome_id)
-end
-
-generator.build_render(:mute) do |value, _proc|
-  if value
-    browser_object.muted
-  else
-    browser_object.unmuted
-  end
-end
-
-generator.build_render(:browser_drag) do |options, proc|
-  options.each do |method, params|
-    atome_id = @atome[:id]
-    BrowserHelper.send("browser_drag_#{method}", params, atome_id, self, proc)
-  end
-end
-
-generator.build_render(:browser_drop) do |options, proc|
-  # puts "method : #{options}, params : #{options}"
-  options.each do |method, params|
-    atome_id = @atome[:id]
-    BrowserHelper.send("browser_drop_#{method}", params, atome_id, self, proc)
-  end
-end
-
-
-generator.build_render(:browser_sort) do |options, _proc|
-  atome_js.JS.sort(options, @atome[:id], self)
-end
-
-# TODO: for now unbind remove all touch event we should remove only the targeted one (store proc and restore it)
-generator.build_render(:browser_unbind) do |options, _proc|
-  id_found = self.atome[:id]
-  `
-//const el = document.getElementById(#{id_found});
-interact('#'+#{id_found}).unset(#{options});
-`
-end
-
-

data/lib/atome/renderers/browser/geometry.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-generator = Genesis.generator
-
-generator.build_render(:browser_width) do |value|
-
-  # aa=BrowserHelper.value_parse(value)
-  # # alert "value_parse : #{aa}"≈
-  # alert "#{value} :  #{value.class} : value_parse : #{aa}"
-  # @browser_object.style[:width] = if value.instance_of? String
-  #                                   value
-  #                                 else
-  #                                   "#{value}px"
-  #                                 end
-
-
-  @browser_object.style[:width] = BrowserHelper.value_parse(value)
-end
-
-generator.build_render(:browser_height) do |value|
-  # @browser_object.style[:height] = if value.instance_of? String
-  #                                    value
-  #                                  else
-  #                                    "#{value}px"
-  #                                  end
-  @browser_object.style[:height] = BrowserHelper.value_parse(value)
-end

data/lib/atome/renderers/browser/helpers/animation_helper.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-# for browser rendering
-module BrowserHelper
-  def self.anim_convertor(value)
-    { left: [:left, "#{value}px"], right: [:right, "#{value}px"], top: [:top, "#{value}px"],
-      bottom: [:bottom, "#{value}px"], smooth: ['border-radius', "#{value}px"],
-      left_add: ['transform', "translateX(#{value}px)"],
-      right_add: ['transform', "translateY(#{value}px)"],
-      width: [:width, "#{value}px"], height: [:height, "#{value}px"] }
-  end
-
-  def self.anim_value_analysis(value, particle_found, atome_found)
-    case value
-    when :self
-      # this case mean the user use the current atome so we get the particle value of the atome
-      value = atome_found.atome[particle_found]
-    when Integer
-      value
-    else
-      # this case mean the user try to pass an id so we get the particle value of the atome
-      value = grab(value).atome[particle_found]
-      value
-    end
-    value
-  end
-
-  def self.send_anim_to_js(animation, atome_hash, atome_found, atome_id, animation_atome)
-    animated_particle = animation[0]
-    start_value = animation[1]
-    end_value = animation[2]
-    original_particle = animation[3]
-    atome_js.JS.animate(animated_particle, atome_hash[:duration], atome_hash[:damping], atome_hash[:ease],
-                       atome_hash[:mass], atome_hash[:repeat], atome_hash[:stiffness], atome_hash[:velocity],
-                       start_value, end_value, atome_id, atome_found, atome_hash, original_particle, animation_atome)
-  end
-
-  def self.sanitize_anim_params(value, particle_found, atome_hash, atome_found, atome_id, animation_atome)
-    start_value = anim_value_analysis(value, particle_found, atome_found)
-    start_value = BrowserHelper.anim_convertor(start_value)[particle_found][1]
-    end_value = anim_value_analysis(atome_hash[:end][particle_found], particle_found, atome_found)
-    end_value = BrowserHelper.anim_convertor(end_value)[particle_found][1]
-    animated_particle = BrowserHelper.anim_convertor(value)[particle_found][0]
-    # animation is a stupid array to satisfy rubocop stupidity
-    animation = [animated_particle, start_value, end_value, particle_found]
-    send_anim_to_js(animation, atome_hash, atome_found, atome_id, animation_atome)
-  end
-
-  def self.anim_pop_motion_converter(atome_hash, atome_found, atome_id, animation_atome)
-    atome_hash[:dampingRatio] = atome_hash.delete(:damping)
-    atome_hash[:begin].each do |particle_found, value|
-      sanitize_anim_params(value, particle_found, atome_hash, atome_found, atome_id, animation_atome)
-    end
-  end
-
-  def self.begin_animation(atome_hash, atome_found, atome_id, animation_atome)
-    anim_pop_motion_converter(atome_hash, atome_found, atome_id, animation_atome)
-  end
-
-  def self.browser_play_animation(_options, _browser_object, atome_hash, animation_atome, proc)
-    atome_hash[:targets] = [:eDen] unless atome_hash[:targets]
-    animation_atome.play_active_proc = proc
-    atome_hash[:targets].each do |target|
-      atome_found = grab(target)
-      atome_id = atome_found.atome[:id]
-      begin_animation(atome_hash, atome_found, atome_id, animation_atome)
-    end
-  end
-end

data/lib/atome/renderers/browser/helpers/browser_helper.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-# for browser rendering
-module BrowserHelper
-  def self.browser_document
-    # Work because of the patched version of opal-browser(0.39)
-    Browser.window
-  end
-
-  def self.browser_attach_(_parents, _html_object, _atome)
-    # dummy methods to catch atomes that do not need to be attached to any particular visual atime
-  end
-
-  def self.browser_attach_div(parents, html_object, _atome)
-    html_object.append_to(browser_document[parents])
-  end
-
-  def self.add_class_to_vector(vector_id, color_id)
-    # TODO : Create a class instead of modifying the vector
-    # get the content the <style> tag
-    # color_class=self.color.last
-    # alert color_class
-    # alert color_class.class
-    # content_style = tag_style.inner_html
-    # color_value = content_style[/background-color:\s*([^;}]+)/, 1]
-    `
-            let parser = new DOMParser();
-    var divElement = document.querySelector('#'+#{vector_id});
-// divElement.style.removeProperty('background-color');
-//divElement.style.backgroundColor = 'transparent';
-    // select the first svg tag inside the div
-    let foundSVG  = divElement.querySelector('svg');
-     let elements = foundSVG.getElementsByTagName("path");
-    Array.from(elements).forEach(el => {
-                el.classList.add(#{color_id});
-            });
-    `
-  end
-
-  def self.browser_attach_style(parents, _html_object, atome)
-    # we test if the atome has a definition ( it means hold some vectors information)
-    if grab(parents).atome[:definition]
-      # tag_style = $document[atome[:id]]
-      # # # get the content the <style> tag
-      # # content_style = tag_style.inner_html
-      # #  extract the color value
-      # alert atome[:id]
-      add_class_to_vector(parents, atome[:id])
-    else
-      browser_document[parents].add_class(atome[:id])
-    end
-  end
-
-  def self.browser_attached_div(children, _html_object, atome)
-    children.each do |child_found|
-      # atome_child.browser_attach_div
-      html_child = grab(child_found).browser_object
-      html_child.append_to(browser_document[atome[:id]])
-    end
-  end
-
-  def self.browser_attached_style(children, _html_object, atome)
-    if atome[:definition]
-      # alert "yes we arrived here :>\n\n=>#{children}, class:\n=>#{children.class} :\n\n=> #{atome} :\n\n=>  #{_html_object}<:"
-      children.each do |child|
-        # tag_style = $document[child]
-        # alert "(#{atome[:id]}, #{child})"
-        add_class_to_vector(atome[:id], child)
-        # get the content the <style> tag
-        #            content_style = tag_style.inner_html
-        #            #  extract the color value
-        #            color_value = content_style[/background-color:\s*([^;}]+)/, 1]
-        #            `
-        #         let parser = new DOMParser();
-        # var divElement = document.querySelector('#'+#{atome[:id]});
-        # // select the first svg tag inside the div
-        # let foundSVG  = divElement.querySelector('svg');
-        #  let elements = foundSVG.getElementsByTagName("path");
-        # Array.from(elements).forEach(el => {
-        #             el.setAttribute("fill", #{color_value});
-        #             el.setAttribute("stroke", #{color_value});
-        #         });
-        # `
-      end
-
-    else
-      # alert "class added : #{children}"
-      # browser_document[atome[:id]].add_class(children)
-    end
-    browser_document[atome[:id]].add_class(children)
-  end
-
-  def self.value_parse(value)
-    if value.instance_of?(String)
-      value
-    else
-      "#{value}px"
-    end
-
-  end
-end

data/lib/atome/renderers/browser/helpers/color_helper.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-# for browser rendering
-module BrowserHelper
-  def self.browser_colorize_color(color_updated, atome)
-    ########################### new code ###########################
-    id_found=atome[:id]
-    new_class_content = <<STR
-.#{id_found} {
-  background-color: #{color_updated};
-  fill: #{color_updated};
-  stroke: #{color_updated};
-}
-STR
-
-    atomic_style = BrowserHelper.browser_document['#atomic_style']
-    # atomic_style.text = atomic_style.text.gsub(/\.#{id_found}\s*{.*?}/m, new_class_content)
-
-    regex = /(\.#{id_found}\s*{)([\s\S]*?)(})/m
-    atomic_style.text = atomic_style.text.gsub(regex, new_class_content)
-
-
-    ########################### old code ###########################
-#
-#     puts  "the code below may be updated to work with the new class handler :\n\n#{color_updated}\n\n#{atome}"
-#     `
-# document.getElementById(#{atome[:id]}).sheet.cssRules[0].style.backgroundColor = #{color_updated}
-# document.getElementById(#{atome[:id]}).sheet.cssRules[0].style.fill = #{color_updated}
-# document.getElementById(#{atome[:id]}).sheet.cssRules[0].style.stroke = #{color_updated}
-# `
-    ########################### new old end ###########################
-
-  end
-
-  def self.browser_colorize_shadow(color_updated, atome)
-    "new shadow color is : #{color_updated}"
-    puts "=====> #{color_updated} : #{atome}"
-    left = atome[:left]
-    top = atome[:top]
-    blur = atome[:blur]
-    direction = atome[:direction]
-    # shadow_updated = "#{left}px #{top}px #{blur}px #{color_updated} #{direction}"
-    # `document.getElementById(#{atome[:id]}).sheet.cssRules[0].style.boxShadow = #{shadow_updated}`
-
-    #new code
-    id_found= atome[:id]
-    class_content = <<STR
-.#{id_found} {
-  box-shadow: #{left}px #{top}px #{blur}px #{color_updated} #{direction};
-}
-STR
-
-    atomic_style = BrowserHelper.browser_document['#atomic_style']
-    # atomic_style.text = atomic_style.text.gsub(/\.#{id_found}\s*{.*?}/m, new_class_content)
-    # puts new_class_content
-    regex = /(\.#{id_found}\s*{)([\s\S]*?)(})/m
-    atomic_style.text = atomic_style.text.gsub(regex, class_content)
-
-    # .view_shadow_17 {
-    # box-shadow: 3px 3px 3px  rgba(0,
-    #   0,0,1)
-    # }
-  end
-
-  def self.browser_left_color(_value, _browser_object, _atome)
-    # puts 'code to write when implementing gradient'
-  end
-
-  def self.browser_right_color(_value, _browser_object, _atome)
-    # puts 'code to write when implementing gradient'
-  end
-
-  def self.browser_top_color(_value, _browser_object, _atome)
-    # puts 'code to write when implementing gradient'
-  end
-
-  def self.browser_bottom_color(_value, _browser_object, _atome)
-    # puts 'code to write when implementing gradient'
-  end
-end

data/lib/atome/renderers/browser/helpers/drag_helper.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-# for browser rendering
-
-module BrowserHelper
-
-  # drag helper
-  def self.browser_drag_move(params, atome_id, atome, proc)
-    atome.drag_move_proc = proc
-    atome_js.JS.drag(params, atome_id, atome)
-  end
-
-  # def self.browser_drag_end(params, atome_id, atome, proc)
-  #   # alert :kool
-  #   # atome.drag_move_proc = proc
-  #   # atome_js.JS.drag(params, atome_id, atome)
-  # end
-
-  def self.browser_drag_lock(params, atome_id, atome, _proc)
-    atome_js.JS.lock(params, atome_id, atome)
-  end
-
-  def self.browser_drag_remove(params, atome_id, atome, _proc)
-    params = params != true
-    atome_js.JS.remove(params, atome_id, atome)
-  end
-
-  def self.browser_drag_snap(params, atome_id, atome, _proc)
-    atome_js.JS.snap(params.to_n, atome_id, atome)
-  end
-
-  def self.browser_drag_inertia(params, atome_id, atome, _proc)
-    atome_js.JS.inertia(params, atome_id, atome)
-  end
-
-  def self.browser_drag_constraint(params, atome_id, atome, _proc)
-    atome_js.JS.constraint(params.to_n, atome_id, atome)
-  end
-
-  def self.browser_drag_start(_params, _atome_id, atome, proc)
-    atome.drag_start_proc = proc
-  end
-
-  def self.browser_drag_end(_params, _atome_id, atome, proc)
-    atome.drag_end_proc = proc
-  end
-
-  def self.browser_drag_start(_params, _atome_id, atome, proc)
-    atome.drag_start_proc = proc
-  end
-
-end

data/lib/atome/renderers/browser/helpers/drop_helper.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-# for browser rendering
-
-module BrowserHelper
-
-  #drop helper
-  def self.browser_drop_action(params, atome_id, atome, proc)
-    atome.drop_action_proc = proc
-    atome_js.JS.drop(params, atome_id, atome)
-  end
-
-end

data/lib/atome/renderers/browser/helpers/effect_helper.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-# for browser rendering
-module BrowserHelper
-
-  def self.browser_blur_style(_browser_object, value, atome)
-    # b_left = "#{atome[:left]}px"
-    # b_top = "#{atome[:top]}px"
-    # b_blur = "#{atome[:blur] = value}px"
-    # b_red = atome[:red] * 255
-    # b_green = atome[:green] * 255
-    # b_blue = (atome[:blue]) * 255
-    # b_direction = atome[:direction]
-    # b_alpha = atome[:alpha]
-
-    # shadow_updated = "#{b_left} #{b_top} #{b_blur} rgba(#{b_red}, #{b_green}, #{b_blue}, #{b_alpha}) #{b_direction}"
-    # `document.getElementById(#{atome[:id]}).sheet.cssRules[0].style.boxShadow = #{shadow_updated}`
-  end
-
-  def self.browser_blur_div(browser_object, value, _atome)
-    browser_object.style[:filter] = "blur(#{value}px)"
-  end
-end

data/lib/atome/renderers/browser/helpers/event_helper.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-# for browser rendering
-module BrowserHelper
-
-  def self.touch_helper_callback(event, atome, proc)
-    atome.instance_exec(event, &proc) if proc.is_a?(Proc)
-  end
-
-  def self.browser_touch_true(browser_object, atome, proc)
-    `
-    interact('#'+#{browser_object})
-  .on('tap', function (event) {
-Opal.BrowserHelper.$touch_helper_callback(event,#{atome},#{proc});
-  })
-`
-  end
-
-  def self.browser_touch_long(browser_object, atome, proc)
-    `
-    interact('#'+#{browser_object})
-  .on('hold', function (event) {
-Opal.BrowserHelper.$touch_helper_callback(event,#{atome},#{proc});
-  })
-`
-  end
-
-  def self.browser_touch_double(browser_object, atome, proc)
-    `
-    interact('#'+#{browser_object})
-  .on('doubletap', function (event) {
-Opal.BrowserHelper.$touch_helper_callback(event,#{atome},#{proc});
-  })
-`
-  end
-
-  def self.browser_touch_down(browser_object, atome, proc)
-
-    `
-    interact('#'+#{browser_object})
-  .on('down', function (event) {
-Opal.BrowserHelper.$touch_helper_callback(event,#{atome},#{proc});
-  })
-
-`
-  end
-
-  def self.browser_touch_up(browser_object, atome, proc)
-    `
-    interact('#'+#{browser_object})
-  .on('up', function (event) {
-Opal.BrowserHelper.$touch_helper_callback(event,#{atome},#{proc});
-  })
-`
-  end
-
-  def self.browser_over_enter(browser_object, atome)
-    browser_object.on :mouseenter do |event|
-      atome.enter_action_callback( event)
-      # atome.instance_exec(event, &proc) if proc.is_a?(Proc)
-      # atome_id = atome.id
-      # atome_js.JS.over_enter(atome_id, atome, proc, :enter)
-    end
-  end
-
-  def self.browser_over_leave(browser_object, atome)
-    browser_object.on :mouseout do |event|
-      atome.leave_action_callback(event)
-      # atome.instance_exec(event, &proc) if proc.is_a?(Proc)
-      # atome_js.JS.over_leave(atome_id, atome,proc,:leave)
-    end
-  end
-
-end
-
-

data/lib/atome/renderers/browser/helpers/image_helper.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-# for browser rendering
-module BrowserHelper
-  # image
-  def self.browser_left_image(value, browser_object, _atome)
-    browser_object.style[:left] = "#{value}px"
-  end
-
-  def self.browser_right_image(value, browser_object, _atome)
-    browser_object.style[:right] = "#{value}px"
-  end
-
-  def self.browser_top_image(value, browser_object, _atome)
-    browser_object.style[:top] = "#{value}px"
-  end
-
-  def self.browser_bottom_image(value, browser_object, _atome)
-    browser_object.style[:bottom] = "#{value}px"
-  end
-
-  def self.browser_path_image(value, browser_object, _atome)
-    browser_object[:src] = value
-  end
-
-
-end

data/lib/atome/renderers/browser/helpers/over_helper.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-# for browser rendering
-
-# module BrowserHelper
-#
-#   #drop helper
-#   def self.browser_over_action(params, atome_id, atome, proc)
-#     # atome.over_action_proc = proc
-#     atome_js.JS.over(params, atome_id, atome)
-#   end
-#
-# end