atome 0.5.3.8.8 → 0.5.4.1.0

data/lib/atome/genesis/generators/event.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-
-
-new({particle: :touch , type: :hash, store: false })
+new({ particle: :touch, type: :hash, store: false })
 new({ post: :touch }) do |params, user_bloc|
   @touch = {} if @touch == nil
   @touch[params] = user_bloc
@@ -10,91 +8,80 @@ new({ post: :touch }) do |params, user_bloc|
   store_value(:touch)
 end
 
-new({particle: :play }) do
+new({ particle: :play }) do
   @atome[:pause] = :false
 end
-new({particle: :time })
-new({particle: :pause }) do
+new({ particle: :time })
+new({ particle: :pause }) do
   @atome[:play] = :false
 end
-new({particle: :on })
-new({particle: :fullscreen })
-new({particle: :mute })
-new({particle: :drag })
-new({ sanitizer: :drag }) do |params|
+new({ particle: :on })
+new({ particle: :fullscreen })
+new({ particle: :mute })
+new({ particle: :drag, store: false })
+
+new({ sanitizer: :drag }) do |params, proc|
   params = { move: true } if params == true
+  params = { end: proc } if params == :end
+  params = { start: proc } if params == :start
+  params
+end
+
+new({ post: :drag }) do |params|
+  # puts  "params is : > #{params}"
+  @drag = {} if @drag == nil
+  # @drag[params] = user_bloc
+  params.each do |k, v|
+    @drag[k] = v
+  end
+  # @drag=params
+  # as store for touch is set to false we have to manually save the instance variable
+  store_value(:drag)
+end
+
+# @touch[params] = user_bloc
+
+new ({ particle: :drop })
+
+new ({ sanitizer: :drop }) do |params|
+  params = { action: true } if params == true
   params
 end
-new({particle: :sort }) do |_value, sort_proc|
+
+new ({ particle: :over })
+
+new ({ sanitizer: :over }) do |params, user_proc|
+
+  params = :enter if params == true
+  case params
+  when :enter
+    @enter_action_proc = user_proc
+  when :leave
+    @leave_action_proc = user_proc
+  end
+  params
+end
+
+new({ particle: :sort }) do |_value, sort_proc|
   @sort_proc = sort_proc
 end
-new({particle: :targets })
-new({particle: :start })
-new({pre: :start }) do |_value, user_proc|
+new({ particle: :targets })
+new({ particle: :start })
+new({ pre: :start }) do |_value, user_proc|
   @animation_start_proc = user_proc
 end
-new({particle: :stop })
-new({pre: :stop })  do |_value, user_proc|
+new({ particle: :stop })
+new({ pre: :stop }) do |_value, user_proc|
   @animation_stop_proc = user_proc
 end
-new({particle: :begin })
-new({particle: :end })
-new({particle: :duration })
-new({particle: :mass })
-new({particle: :damping })
-new({particle: :stiffness })
-new({particle: :velocity })
-new({particle: :repeat })
-new({particle: :ease })
-new({particle: :unbind })
-new({particle: :over })
-
+new({ particle: :begin })
+new({ particle: :end })
+new({ particle: :duration })
+new({ particle: :mass })
+new({ particle: :damping })
+new({ particle: :stiffness })
+new({ particle: :velocity })
+new({ particle: :repeat })
+new({ particle: :ease })
+new({ particle: :unbind })
 
-# generator = Genesis.generator
-#
-# # touch
-# generator.build_particle(:touch)
-# # video
-# generator.build_particle(:play) do
-#   @atome[:pause] = :false
-# end
-# generator.build_particle(:time)
-# generator.build_particle(:pause) do
-#   @atome[:play] = :false
-# end
-# generator.build_particle(:on)
-# generator.build_particle(:fullscreen)
-# generator.build_particle(:mute)
-# # TODO : add the at event to ny particle : (width, left, ...) maybe use monitor particle
-# # generator.build_particle(:at)
-# # drag
-# generator.build_particle(:drag)
-# generator.build_sanitizer(:drag) do |params|
-#   params = { move: true } if params == true
-#   params
-# end
-# # sort
-# generator.build_particle(:sort) do |_value, sort_proc|
-#   @sort_proc = sort_proc
-# end
-# # animation
-# generator.build_particle(:targets)
-# generator.build_particle(:start)
-# generator.build_option(:pre_render_start) do |_value, user_proc|
-#   @animation_start_proc = user_proc
-# end
-# generator.build_particle(:stop)
-# generator.build_option(:pre_render_stop) do |_value, user_proc|
-#   @animation_stop_proc = user_proc
-# end
-# generator.build_particle(:begin)
-# generator.build_particle(:end)
-# generator.build_particle(:duration)
-# generator.build_particle(:mass)
-# generator.build_particle(:damping)
-# generator.build_particle(:stiffness)
-# generator.build_particle(:velocity)
-# generator.build_particle(:repeat)
-# generator.build_particle(:ease)
-# generator.build_particle(:unbind)
-# generator.build_particle(:over)

data/lib/atome/genesis/generators/geometry.rb

@@ -14,21 +14,3 @@ new({particle: :size }) do |params|
     height(params)
   end
 end
-
-
-# generator = Genesis.generator
-#
-# generator.build_particle(:width)
-# generator.build_particle(:height)
-# generator.build_particle(:size) do |params|
-#   atome_width = atome[:width]
-#   atome_height = atome[:height]
-#   aspect_ratio = atome_width / atome_height
-#   if atome_width > atome_height
-#     width(params)
-#     height(params / aspect_ratio)
-#   else
-#     width(params * aspect_ratio)
-#     height(params)
-#   end
-# end

data/lib/atome/genesis/generators/identity.rb

@@ -2,10 +2,10 @@
 
 new({ particle: :attach })
 new({ sanitizer: :attach }) do |parents_ids|
-  parents_ids = parents_ids.value if parents_ids.instance_of? Atome
+  parents_ids = parents_ids if parents_ids.instance_of? Atome
   parents_ids = [parents_ids] unless parents_ids.instance_of?(Array)
   parents_ids.each do |parents_id|
-    parents_id = parents_id.value if parents_id.instance_of? Atome
+    parents_id = parents_id if parents_id.instance_of? Atome
     parents_found = grab(parents_id)
     # TODO : factorise the code below
     current_type = atome[:type]
@@ -23,23 +23,19 @@ new({ sanitizer: :attach }) do |parents_ids|
     parents_found.atome[:attached] = [] unless parents_found.atome[:attached]
     parents_found.atome[:attached] << atome[:id]
   end
-  # atome[:parents]=atome[:parents] | parents_ids
-  # atome[:parents].concat(parents_ids).uni
-  # puts "==> #{id} : #{self}"
-  # puts "====> id : #{id}, #{parents_ids} #{atome[:parents]}, #{atome[:parents].class} : #{atome[:parents].class}"
   parents_ids
 end
 
 new({ particle: :attached })
 new({ sanitizer: :attached }) do |children_ids|
-  children_ids = children_ids.value if children_ids.instance_of? Atome
+  children_ids = children_ids if children_ids.instance_of? Atome
   children_ids = [children_ids] unless children_ids.instance_of?(Array)
   children_ids.each do |child_id|
-    child_id = child_id.value if child_id.instance_of? Atome
+    child_id = child_id if child_id.instance_of? Atome
     child_found = grab(child_id)
     parents_found = @atome[:id]
     # TODO : factorise the code below
-    child_found_type = child_found.type.value
+    child_found_type = child_found.type
     @atome[child_found_type] = [] unless @atome[child_found_type]
 
     # the condition below is needed when user passed a hash instead of the id of the child cf :
@@ -51,8 +47,6 @@ new({ sanitizer: :attached }) do |children_ids|
                            end
     child_type_container << child_id
     # TODO : factorise the code above
-
-    # child_found.family(parents_found)
     child_found.atome[:attach] = [parents_found]
   end
 end
@@ -67,33 +61,12 @@ new({ sanitizer: :detached }) do |values|
   else
     detach_atome(values)
     # we sanitize the values so it always return an array to the renderer
-    values=[values]
+    values = [values]
   end
   values
 end
 
 new({ particle: :type })
-
-# new({ particle: :parents })
-# new({ sanitizer: :parents }) do |params|
-#   params = [params] unless params.instance_of? Array
-#   sanitized_params = []
-#   params.each do |parents_id|
-#     parents_id = parents_id.value if parents_id.instance_of? Atome
-#     sanitized_params << parents_id
-#     parents_found = grab(parents_id)
-#     # TODO : factorise the code below
-#     current_type = atome[:type]
-#     parents_found.atome[current_type] = [] unless parents_found.atome[current_type]
-#     parents_found.atome[current_type] << atome[:id]
-#     # TODO : factorise the code above
-#     # TODO : check if we can remove the family
-#     family(parents_id)
-#   end
-#   sanitized_params
-# end
-
-# new({ particle: :family })
 new({ particle: :id })
 new({ sanitizer: :id }) do |params|
   if @atome[:id] != params

data/lib/atome/genesis/generators/material.rb

@@ -30,6 +30,7 @@ new({ pre: :style }) do |styles_send, _user_proc|
   end
 end
 new({ particle: :hide })
+
 new({ particle: :remove }) do |particle_to_remove|
   case particle_to_remove
   when :color
@@ -43,62 +44,45 @@ new({ particle: :remove }) do |particle_to_remove|
 end
 new({ particle: :classes }) do |value|
   Universe.classes[value] ||= []
-  Universe.classes[value] |= [id.value]
+  Universe.classes[value] |= [id]
 end
 new({ particle: :remove_classes }) do |value|
   # Universe.classes.delete(value)
-  Universe.classes[value].delete(id.value)
+  Universe.classes[value].delete(id)
 end
 new ({particle: :opacity})
 
-# generator = Genesis.generator
-#
-# generator.build_particle(:red) do
-#   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
-#   self
-# end
-# generator.build_particle(:green) do
-#   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
-#   self
-# end
-# generator.build_particle(:blue) do
-#   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
-#   self
-# end
-# generator.build_particle(:alpha) do
-#   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
-#   self
-# end
-# generator.build_particle(:diffusion) do
-#   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
-#   self
-# end
-# generator.build_particle(:visual)
-# generator.build_particle(:overflow)
-# generator.build_particle(:edit)
-# generator.build_particle(:style)
-# generator.build_option(:pre_render_style) do |styles_send, _user_proc|
-#   styles_send.each do |particle_send, value|
-#     send(particle_send, value)
-#   end
-# end
-# generator.build_particle(:hide)
-# generator.build_particle(:remove) do |particle_to_remove|
-#   case particle_to_remove
-#   when :color
-#     send(particle_to_remove, :black)
-#   when :shadow
-#     # TODO : code to write
-#     puts 'code to write'
-#   else
-#     particle_to_remove_decision(particle_to_remove)
-#   end
-# end
-# generator.build_particle(:classes) do |value|
-#   Universe.classes[value] ||= []
-#   Universe.classes[value] |= [id.value]
-# end
-# generator.build_particle(:remove_classes) do |value|
-#   # Universe.classes.delete(value)
-#   Universe.classes[value].delete(id.value)
-# end
+
+# vector shape
+new({particle: :definition})
+
+new({ browser: :definition, type: :string }) do |value, _user_proc|
+  # alert "value is #{value}"
+  target=id
+  `
+
+var divElement =  document.querySelector('#'+#{target});;
+
+// select the first svg tag inside the div
+var svgElement = divElement.querySelector('svg');
+
+// delete the first svg tag inside the div if it exist
+if (svgElement) {
+  divElement.removeChild(svgElement);
+}
+
+
+  let svg_content='<svg style="width: 1em; height: 1em;vertical-align: middle;fill: currentColor;overflow: hidden;" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg">'+#{value}+'</svg>'
+       let svgContainer = document.getElementById(#{target});
+        let parser = new DOMParser();
+        let svgDoc = parser.parseFromString(svg_content, "image/svg+xml");
+        let importedSVG = svgDoc.getElementsByTagName("svg")[0];
+        importedSVG.style.width =  "100%";
+        importedSVG.style.height =  "100%";
+        let elements = importedSVG.getElementsByTagName("path");
+
+        svgContainer.appendChild(importedSVG);
+
+`
+
+end

data/lib/atome/genesis/generators/utility.rb

@@ -9,16 +9,40 @@ end
 new({ particle: :broadcast })
 new({ particle: :data })
 # new({particle: :additional })
-new({ particle: :delete }) do |params|
+new({ particle: :delete, render: false }) do |params, &user_proc|
   if params == true
-    # now we detach the atome from it's parent
-    parents_found = @atome[:attach]
-    parents_found.each do |parent_found|
-      grab(parent_found).detached(@atome[:id])
+    # We use the tag persistent to exclude color of system object and other default colors
+    unless tag && tag[:persistent]
+      # now we detach the atome from it's parent
+      # now we init rendering
+      rendering(:delete, params, &user_proc)
+      # the machine delete the current atome from the universe
+      id_found = @atome[:id]
+      Universe.delete(id_found)
+      parents_found = @atome[:attach]
+      parents_found.each do |parent_id_found|
+        parent_found = grab(parent_id_found)
+        next unless parent_found
+
+        previous_parent_type_child = parent_found.atome[type]
+        previous_parent_attached_child = parent_found.atome[:attached]
+        # FIXME : find why we can't use delete on the array nut must use an iterator
+        new_type_container = []
+        previous_parent_type_child.each do |atome_found|
+          new_type_container << atome_found unless atome_found == id_found
+        end
+        parent_found.atome[type] = new_type_container
+        # FIXME : find why we can't use delete on the array nut must use an iterator
+        new_attached_container = []
+        previous_parent_attached_child.each do |atome_found|
+          new_attached_container << atome_found unless atome_found == id_found
+        end
+        parent_found.atome[:attached] = new_attached_container
+
+      end
+
     end
 
-    # the machine delete the current atome from the universe
-    Universe.delete(@atome[:id])
   elsif params == :materials
     # this will delete any child with a visual type cf : images, shapes, videos, ...
     materials.each do |atome_id_found|
@@ -26,6 +50,13 @@ new({ particle: :delete }) do |params|
     end
   elsif params[:id]
     # the machine try to an atome by it's ID and delete it
+    # We check for recursive, if found we delete attached atomes too
+    if params[:recursive] == true
+      materials_found = grab(params[:id]).materials
+      materials_found.each do |atome_id_found|
+        grab(atome_id_found).delete(true)
+      end
+    end
     grab(params[:id]).delete(true)
   elsif params.instance_of? Hash
     # the machine try to find the sub particle id and remove it eg a.delete(monitor: :my_monitor) remove the monitor
@@ -34,11 +65,28 @@ new({ particle: :delete }) do |params|
       atome[param][value] = nil
     end
   else
-    # the machine try to reset the current particle(params), eg a.delete(:left) => left: 0
     send(params, 0)
   end
 end
+
 new({ particle: :clear })
+new({ post: :clear }) do
+
+  attached_found = []
+  @atome[:attached].each do |attached_id_found|
+    attached_found << attached_id_found
+  end
+  attached_found.each do |child_id_found|
+    # puts "===>> should be deleted : #{child_id_found}"
+    child_found = grab(child_id_found)
+
+    child_found.delete(true) if child_found
+
+    # Universe.delete(child_id_found)
+  end
+  # attached([])
+  # puts "params are => #{id}"
+end
 new({ particle: :path })
 new({ particle: :schedule }) do |date, proc|
   date = date.to_s
@@ -56,54 +104,11 @@ end
 new({ particle: :cursor })
 new({ particle: :preset })
 new({ particle: :relations, type: :hash })
+new({ particle: :tag, render: false, type: :hash })
+new({ particle: :batch, render: false })
+new({ sanitizer: :batch }) do |params|
+  Batch.new(params)
+  # puts "index msg : we must treat the batch : #{params}"
+
+end
 
-# generator = Genesis.generator
-#
-#
-#
-#
-# generator.build_particle(:renderers)
-# generator.build_particle(:code)
-# generator.build_particle(:run) do |params|
-#   code_found = @atome[:code]
-#   instance_exec(params, &code_found) if code_found.is_a?(Proc)
-# end
-# generator.build_particle(:broadcast)
-# generator.build_particle(:additional)
-# generator.build_particle(:data)
-# generator.build_particle(:delete) do |params|
-#   if params == true
-#     # the machine delete the current atome
-#     Universe.delete(@atome[:id])
-#   elsif params[:id]
-#     # the machine try to an atome by it's ID and delete it
-#     grab(params[:id]).delete(true)
-#   elsif params.instance_of? Hash
-#     # the machine try to find the sub particle id and remove it eg a.delete(monitor: :my_monitor) remove the monitor
-#     # with id my_monitor
-#     params.each do |param, value|
-#       atome[param][value] = nil
-#     end
-#   else
-#     # the machine try to reset the current particle(params), eg a.delete(:left) => left: 0
-#     send(params, 0)
-#   end
-# end
-# generator.build_particle(:clear)
-# generator.build_particle(:path)
-# generator.build_particle(:schedule) do |date, proc|
-#   date = date.to_s
-#   delimiters = [',', ' ', ':', '-']
-#   format_date = date.split(Regexp.union(delimiters))
-#   Universe.renderer_list.each do |renderer|
-#     send("#{renderer}_schedule", format_date, &proc)
-#   end
-# end
-# generator.build_particle(:read) do |file, proc|
-#   Universe.renderer_list.each do |renderer|
-#     send("#{renderer}_reader", file, &proc)
-#   end
-# end
-# generator.build_particle(:cursor)
-# generator.build_particle(:preset)
-# generator.build_particle(:relations, { type: :hash })

data/lib/atome/genesis/genesis.rb

@@ -22,6 +22,8 @@ class Atome
     # we add the new method to the particle's collection of methods
     Universe.add_to_particle_list(particle_name, type)
     # the line below create an empty particle method for each renderer, eg: browser_left, headless_width, ...
+    # the line below create the corresponding particle method for Batch class
+    particle_method_for_batch(particle_name)
     auto_render_generator(particle_name) if render
     new_particle(particle_name, store, render, &particle_proc)
     # the line below create all alternatives methods such as create 'method='
@@ -32,6 +34,11 @@ class Atome
     # TODO : atomes should tell the Universe if they're parts of materials category or else
     # we add the new method to the atome's collection of methods
     Universe.add_to_atome_list(atome_name)
+    # the method below generate Atome method creation at Object level,
+    # so a syntax like : 'text(:hello)' is possible instead of the mandatory : grab(:view).text(:hello)
+    atome_method_for_object(atome_name)
+    # the line below create the corresponding atome method for Batch class
+    atome_method_for_batch(atome_name)
     unless Essentials.default_params[atome_name]
       # if it doesn't exist
       # we create default params for the new created atome, adding the hash to : module essential, @default_params
@@ -60,6 +67,7 @@ class Atome
   end
 
   def build_option(method_name, &method_proc)
+    #puts "2 => #{method_name}"
     Universe.add_optional_method(method_name.to_sym, &method_proc)
   end
 end

data/lib/atome/genesis/sparkle.rb

@@ -18,51 +18,61 @@ end
 # now let's get the default render engine
 default_render = Essentials.default_params[:render_engines]
 
+
+def atome_infos
+  puts "atome version: #{Atome::VERSION}"
+  # puts "application identity: #{Universe.app_identity}"
+  puts "application identity:  #{Atome::aui}"
+  # puts "application mode:  #{Atome.mode}"
+  puts "host framework:  #{$host}"
+  puts "script mode: #{Universe.current_machine}"
+  puts "user: #{Universe.current_user}"
+  puts "server: #{Universe.current_server}"
+end
+
 Universe.current_user = :jeezs
-puts "application identity: #{Universe.app_identity}"
-puts "atome version: #{Atome::VERSION}"
-puts "current host: #{Universe.current_machine}"
-puts "current user: #{Universe.current_user}"
-puts "current server: #{Universe.current_server}"
+
+
+atome_infos
 
 Atome.new(
-  { element: { renderers: [], id: :eDen, type: :element} }
+  { element: { renderers: [], id: :eDen, type: :element , tag: {system: true}} }
 )
 
 Atome.new(
-  { element: { renderers: [], id: :user_view, type: :element,
-               attach: [:eDen] } }
+  { element: { renderers: [], id: :user_view, type: :element, tag: {system: true},
+attach: [:eDen] } }
 )
 
 # color creation
 Atome.new(
-  { color: { renderers: default_render, id: :view_color, type: :color,
+  { color: { renderers: default_render, id: :view_color, type: :color,tag: ({persistent: true}),
              red: 0.15, green: 0.15, blue: 0.15, alpha: 1 } }
 )
 
 Atome.new(
-  { color: { renderers: default_render, id: :shape_color, type: :color,
+  { color: { renderers: default_render, id: :shape_color, type: :color,tag: ({persistent: true}),
              red: 0.4, green: 0.4, blue: 0.4, alpha: 1 } }
 )
 
 Atome.new(
-  { color: { renderers: default_render, id: :box_color, type: :color,
+  { color: { renderers: default_render, id: :box_color, type: :color,tag: ({persistent: true}),
              red: 0.5, green: 0.5, blue: 0.5, alpha: 1 } }
 )
 
 Atome.new(
-  { color: { renderers: default_render, id: :text_color, type: :color,
+  { color: { renderers: default_render, id: :text_color, type: :color,tag: ({persistent: true}),
              red: 0.3, green: 0.3, blue: 0.3, alpha: 1 } }
 )
 
 Atome.new(
-  { color: { renderers: default_render, id: :circle_color, type: :color,
+  { color: { renderers: default_render, id: :circle_color, type: :color,tag: ({persistent: true}),
              red: 0.6, green: 0.6, blue: 0.6, alpha: 1 } }
 )
 
 Atome.new(
 
-  { color: { renderers: default_render, id: :matrix_color, type: :color,
+  { color: { renderers: default_render, id: :matrix_color, type: :color,tag: ({persistent: true}),
              left: 0, top: 0, red: 0.7, green: 0.7, blue: 0.7, alpha: 1, diffusion: :linear } }
 )
 
@@ -70,16 +80,25 @@ Atome.new(
 # the black_matter is used to store un materialized atomes
 Atome.new(
   { shape: { renderers: default_render, id: :black_matter, type: :shape, attach: [:user_view],
-             left: 0, right: 0, top: 0, bottom: 0, width: 0, height: 0, overflow: :hidden
+             left: 0, right: 0, top: 0, bottom: 0, width: 0, height: 0, overflow: :hidden, tag: {system: true}
   } })
+
 # view port
 Atome.new(
-  { shape: { renderers: default_render, id: :view, type: :shape, attach: [:user_view],
+  { shape: { renderers: default_render, id: :view, type: :shape, attach: [:user_view], tag: {system: true},
              attached: :view_color, left: 0, right: 0, top: 0, bottom: 0, width: :auto, height: :auto, overflow: :auto,
   }
   }
 )
 
+#unreal port
+Atome.new(
+  { shape: { renderers: default_render, id: :intuition, type: :shape, attach: [:user_view], tag: {system: true},
+             left: 0,  top: 0, width: 0, height: 0, overflow: :visible,
+  }
+  }
+)
+
 # init basic object for atome environment
 
 # Atome.new is used  to create a new atome using best performances but params must be formatted and ordered correctly