atome 0.5.7.0.3 → 0.3191

data/lib/renderers/html/event.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-new({ method: :drag, type: :symbol, renderer: :html }) do |params|
-  # if @drag
-  #   option = @drag[params]
-  # else
-  #   params = :remove
-  #   option = true
-  # end
-  # html.event(:drag, params, option)
-
-  if params
-    option = @drag[params]
-    html.event(:drag, params, option)
-  else
-    html.event(:drag, :remove, true)
-  end
-end
-
-new({ method: :drop, type: :symbol, renderer: :html }) do |params|
-  option = @drop[params]
-  html.event(:drop, params, option)
-end
-
-new({ method: :touch, type: :integer, renderer: :html }) do |params|
-  if params
-    option = @touch[params]
-    html.event(:touch, params, option)
-  else
-    html.event(:touch, :remove, true)
-  end
-end
-
-new({ method: :over, type: :integer, renderer: :html }) do |params|
-  option = @over[params]
-  html.event(:over, params, option)
-end
-
-new({ method: :keyboard, renderer: :html }) do |params|
-  option = @keyboard[params]
-  html.event(:keyboard, params, option)
-end
-
-new({ method: :play, renderer: :html }) do |params = true|
-  option = @play[params]
-  # html.currentTime(params, option) if params != true
-  html.action(:play, params, option)
-  # params
-end
-
-new({ method: :on, renderer: :html }) do |params|
-  option = @on[params]
-  html.on(params, option)
-end
-
-new({ method: :resize, renderer: :html }) do |params, user_bloc|
-  option = @resize[params]
-  html.resize(params, option)
-end

data/lib/renderers/html/geometry.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-# new({ method: :width, type: :integer, renderer: :html }) do |value, _user_proc|
-#   unit_found = metrics[:width]
-#   if unit_found
-#     html.style(:width, "#{value}#{unit_found}")
-#   elsif value.is_a?(Numeric)
-#     html.style(:width, "#{value}px")
-#   else
-#     html.style(:width, value)
-#   end
-# end
-#
-# new({ method: :height, renderer: :html, type: :string }) do |value, _user_proc|
-#   unit_found = metrics,
-#     [:height]
-#   if unit_found
-#     html.style(:height, "#{value}#{unit_found}")
-#   elsif value.is_a?(Numeric)
-#     html.style(:height, "#{value}px")
-#   else
-#     html.style(:height, value)
-#   end
-# end
-
-new({ method: :width, renderer: :html, type: :int }) do |params, _user_proc|
-  unit = @unit[:width] || :px if params.is_a? Numeric
-  js[:style][:width] = "#{params}#{unit}"
-end
-
-new({ method: :height, renderer: :html, type: :int }) do |params, _user_proc|
-  unit = @unit[:height] || :px if params.is_a? Numeric
-  js[:style][:height] = "#{params}#{unit}"
-end
-
-
-# new({ method: :size, type: :hash, renderer: :html }) do |value, _user_proc|
-#   # html.style('fontSize',"#{value}px")
-# end
-#
-#
-# new({ method: :size, type: :int, renderer: :html }) do |value, _user_proc|
-#   # html.style('fontSize', "#{value}px")
-# end
-
-
-new({ method: :size, type: :int, renderer: :html, specific: :text }) do |value, _user_proc|
-  html.style('fontSize', "#{value}px")
-end

data/lib/renderers/html/hierarchy.rb

@@ -1,248 +0,0 @@
-# frozen_string_literal: true
-
-new({ renderer: :html, method: :attach, type: :string }) do |parent_found, _user_proc|
-  html.append_to(parent_found)
-end
-
-new({ renderer: :html, method: :apply, type: :string }) do |parent_found, _user_proc|
-
-  # TODO : factorise code below between text and shape, especially shadow as code is written twice and  identical
-  case parent_found.type
-  when :shadow
-    shadows_to_apply = { filter: [], boxShadow: [] }
-    shadow.each do |shadow_id_found|
-      shadow_found = grab(shadow_id_found)
-      red = shadow_found.red * 255
-      green = shadow_found.green * 255
-      blue = shadow_found.blue * 255
-      alpha = shadow_found.alpha
-      left = shadow_found.left
-      top = shadow_found.top
-      blur = shadow_found.blur[:value] # new correct behavior all atome's value should now be get using :value,here to resolve conflict  with blur and back blur
-      inset = :inset if shadow_found.invert
-      if shadow_found.option == :natural
-        shadows_to_apply[:filter] << "drop-shadow(#{left}px #{top}px #{blur}px rgba(#{red}, #{green}, #{blue}, #{alpha}))"
-      else
-        shadows_to_apply[:boxShadow] << "#{left}px #{top}px #{blur}px rgba(#{red}, #{green}, #{blue}, #{alpha}) #{inset}"
-      end
-    end
-    drop_shadow = shadows_to_apply[:filter].join(' ')
-    box_shadow = shadows_to_apply[:boxShadow].join(',')
-    html.style("transform", "translate3d(0, 0, 0)")
-    html.style("boxShadow", box_shadow)
-    html.style("filter", drop_shadow)
-  when :color
-    red = parent_found.red * 255
-    green = parent_found.green * 255
-    blue = parent_found.blue * 255
-    alpha = parent_found.alpha
-    html.style(:backgroundColor, "rgba(#{red}, #{green}, #{blue}, #{alpha})")
-    if type.to_sym ==:border
-      affect.each do |at_found|
-        grab(at_found).html.style(:border, "solid 2px rgba(#{red},#{green},#{blue},#{alpha})")
-      end
-    end
-  when :paint
-    # if when found colors when use it for the gradient , else whe use the colors within the current atome
-    # gradient_found = params[:colors] || @apply
-    # we get all the paint atomes applied to the current atome
-    gradients_to_apply = []
-    paint.each do |paint_id|
-      colors_to_apply = []
-      # now we get the paint atome
-      paint_atome = grab(paint_id)
-      paint_diffusion = paint_atome.diffusion
-      paint_direction = paint_atome.direction
-      diffusion = paint_diffusion || :linear
-      if paint_direction && paint_direction == :linear
-        direction = " to #{params[:direction]},"
-      elsif diffusion == :linear
-        direction = ' to bottom,'
-      end
-
-      direction = "#{paint_atome.rotate}deg," if paint_atome.rotate
-
-      # now we get the gradient and the color insied
-      paint_atome.gradient.each do |color_id|
-        color_found = grab(color_id)
-        red = color_found.red * 255
-        green = color_found.green * 255
-        blue = color_found.blue * 255
-        alpha = color_found.alpha
-        colors_to_apply << "rgba(#{red}, #{green}, #{blue}, #{alpha})"
-      end
-      colors_to_apply = colors_to_apply.join(',')
-      gradients_to_apply << "#{diffusion}-gradient(#{direction} #{colors_to_apply})"
-    end
-    # TODO : create complexe gradient staking the gradients uncommenting the line below
-    # beware the colors_to_apply syntax is incorrect for complexe gradient
-    # full_gradient_to_apply=gradients_to_apply.join(',')
-    full_gradient_to_apply = gradients_to_apply.last
-    html.style(:background, full_gradient_to_apply)
-  when :border
-    border.each do |border_id_found|
-      border_found = grab(border_id_found)
-      red = border_found.red * 255
-      green = border_found.green * 255
-      blue = border_found.blue * 255
-      alpha = border_found.alpha
-      thickness = border_found.thickness
-      pattern = border_found.pattern
-      html.style(:border, "#{pattern} #{thickness}px rgba(#{red},#{green},#{blue},#{alpha})")
-    end
-  else
-    #
-  end
-end
-
-new({ renderer: :html, method: :apply, type: :string, specific: :text }) do |parent_found, _user_proc|
-  # TODO:   we should treat objet when multiple : #{self.inspect}
-  case parent_found.type
-  when :shadow
-    shadows_to_apply = { filter: [], boxShadow: [] }
-    shadow.each do |shadow_id_found|
-      shadow_found = grab(shadow_id_found)
-      red = shadow_found.red * 255
-      green = shadow_found.green * 255
-      blue = shadow_found.blue * 255
-      alpha = shadow_found.alpha
-      left = shadow_found.left
-      top = shadow_found.top
-      blur = shadow_found.blur[:value] # new correct behavior all atome's value should now be get using :value,here to resolve conflict  with blur and back blur
-      inset = :inset if shadow_found.invert
-      if shadow_found.option == :natural
-        shadows_to_apply[:filter] << "drop-shadow(#{left}px #{top}px #{blur}px rgba(#{red}, #{green}, #{blue}, #{alpha}))"
-      else
-        shadows_to_apply[:boxShadow] << "#{left}px #{top}px #{blur}px rgba(#{red}, #{green}, #{blue}, #{alpha}) #{inset}"
-      end
-    end
-    drop_shadow = shadows_to_apply[:filter].join(' ')
-    box_shadow = shadows_to_apply[:boxShadow].join(',')
-    html.style("transform", "translate3d(0, 0, 0)")
-    html.style("boxShadow", box_shadow)
-    html.style("filter", drop_shadow)
-  when :color
-    red = parent_found.red * 255
-    green = parent_found.green * 255
-    blue = parent_found.blue * 255
-    alpha = parent_found.alpha
-    html.style(:color, "rgba(#{red}, #{green}, #{blue}, #{alpha})")
-  when :paint
-    # if when found colors when use it for the gradient , else whe use the colors within the current atome
-    # gradient_found = params[:colors] || @apply
-    # we get all the paint atomes applied to the current atome
-    gradients_to_apply = []
-    paint.each do |paint_id|
-      colors_to_apply = []
-      # now we get the paint atome
-      paint_atome = grab(paint_id)
-      paint_diffusion = paint_atome.diffusion
-      paint_direction = paint_atome.direction
-      diffusion = paint_diffusion || :linear
-      if paint_direction && paint_direction == :linear
-        direction = " to #{params[:direction]},"
-      elsif diffusion == :linear
-        direction = ' to bottom,'
-      end
-
-      if paint_atome.rotate
-        direction = "#{paint_atome.rotate}deg,"
-      end
-
-      # now we get the gradient and the color insied
-      paint_atome.gradient.each do |color_id|
-        color_found = grab(color_id)
-        red = color_found.red * 255
-        green = color_found.green * 255
-        blue = color_found.blue * 255
-        alpha = color_found.alpha
-        colors_to_apply << "rgba(#{red}, #{green}, #{blue}, #{alpha})"
-      end
-      colors_to_apply = colors_to_apply.join(',')
-      gradients_to_apply << "#{diffusion}-gradient(#{direction} #{colors_to_apply})"
-    end
-    # TODO : create complexe gradient staking the gradients uncommenting the line below
-    # beware the colors_to_apply syntax is incorrect for complexe gradient
-    # full_gradient_to_apply=gradients_to_apply.join(',')
-    full_gradient_to_apply = gradients_to_apply.last
-
-    html.style(:backgroundClip, 'text')
-    html.style(:color, 'transparent')
-    html.style(:backgroundImage, full_gradient_to_apply)
-  end
-
-end
-
-new({ renderer: :html, method: :apply, type: :string, specific: :vector }) do |parent_found, _user_proc|
-
-  # TODO : factorise code below between text and shape, especially shadow as code is written twice and  identical
-  case parent_found.type
-  when :shadow
-    shadows_to_apply = { filter: [], boxShadow: [] }
-    shadow.each do |shadow_id_found|
-      shadow_found = grab(shadow_id_found)
-      red = shadow_found.red * 255
-      green = shadow_found.green * 255
-      blue = shadow_found.blue * 255
-      alpha = shadow_found.alpha
-      left = shadow_found.left
-      top = shadow_found.top
-      blur = shadow_found.blur
-      inset = :inset if shadow_found.invert
-      if shadow_found.option == :natural
-        shadows_to_apply[:filter] << "drop-shadow(#{left}px #{top}px #{blur}px rgba(#{red}, #{green}, #{blue}, #{alpha}))"
-      else
-        shadows_to_apply[:boxShadow] << "#{left}px #{top}px #{blur}px rgba(#{red}, #{green}, #{blue}, #{alpha}) #{inset}"
-      end
-    end
-    drop_shadow = shadows_to_apply[:filter].join(' ')
-    box_shadow = shadows_to_apply[:boxShadow].join(',')
-    html.style("transform", "translate3d(0, 0, 0)")
-    html.style("boxShadow", box_shadow)
-    html.style("filter", drop_shadow)
-  when :color
-    red = parent_found.red * 255
-    green = parent_found.green * 255
-    blue = parent_found.blue * 255
-    alpha = parent_found.alpha
-    html.colorize_svg_data("rgba(#{red}, #{green}, #{blue}, #{alpha})")
-  when :paint
-
-    # if when found colors when use it for the gradient , else whe use the colors within the current atome
-    # gradient_found = params[:colors] || @apply
-    # we get all the paint atomes applied to the current atome
-    gradients_to_apply = []
-    paint.each do |paint_id|
-      colors_to_apply = []
-      # now we get the paint atome
-      paint_atome = grab(paint_id)
-      paint_diffusion = paint_atome.diffusion
-      paint_direction = paint_atome.direction
-      diffusion = paint_diffusion || :linear
-      if paint_direction && paint_direction == :linear
-        direction = " to #{params[:direction]},"
-      elsif diffusion == :linear
-        direction = ' to bottom,'
-      end
-
-      direction = "#{paint_atome.rotate}deg," if paint_atome.rotate
-
-      # now we get the gradient and the color insied
-      paint_atome.gradient.each do |color_id|
-        color_found = grab(color_id)
-        red = color_found.red * 255
-        green = color_found.green * 255
-        blue = color_found.blue * 255
-        alpha = color_found.alpha
-        colors_to_apply << "rgba(#{red}, #{green}, #{blue}, #{alpha})"
-      end
-      colors_to_apply = colors_to_apply.join(',')
-      gradients_to_apply << "#{diffusion}-gradient(#{direction} #{colors_to_apply})"
-    end
-    # TODO : create complexe gradient staking the gradients uncommenting the line below
-    # beware the colors_to_apply syntax is incorrect for complexe gradient
-    # full_gradient_to_apply=gradients_to_apply.join(',')
-    full_gradient_to_apply = gradients_to_apply.last
-    html.style(:background, full_gradient_to_apply)
-  end
-end