atome 0.5.6.7.8 → 0.5.6.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65f6cf64a7ecd0b856f3a84bbd519314197caa2745a1150ba9b2ed8a124c7e87
-  data.tar.gz: 0d8a07920c05601ad82a3e6abaf9748316b190cfbec203ae0bd1d8045da44efc
+  metadata.gz: 56128962742a3c148f7ce1187577af8438466642a81d1b227e0c3ab66275e322
+  data.tar.gz: aada78b1931101f52fe14e414e0396e9e15eb03754005d0836b1198f1b0091ac
 SHA512:
-  metadata.gz: 7f8e08c7ecd5716e16a798637ba60309537948906d370c35f8594267d43ec6f42fb3b648fa0c544c4d8d09790589c24bfa2725f2702c269727790ce79ec0a17a
-  data.tar.gz: dbb3a6e0642b2908e6acf1634dd2d06fe2d263609cdb5b2b5f49d87b466eda7f64a5ffeae09336b8cdd22622f270045b7c0b9c8f2125531f6c0fa37dbda86c7f
+  metadata.gz: 817bee9de2868ed5983838b98a6b650423f04dbf4d5f35ceb20c2315b6ae54c991465e31c2e10ee74f8300d963e4106e53d036f1ecbd2ef10d668783e3194cc9
+  data.tar.gz: 6f075107a7e5b85f33ae0d0e757025a0702447365d7ffdb048b65a4f89138ac3d8e95acfb53b795b9a9743b2229692bae3edf32f17597a5bdc5e578dc26cede5

data/lib/atome/atome.rb

@@ -5,6 +5,8 @@
 # Atome.instance_variable_set('@initialized',{})
 class Atome
   include Essentials
+  # controller_proc is used to stack multiple procs from native controller
+  attr_accessor :controller_proc
 
   def aid(_v = nil)
     @aid
@@ -36,6 +38,7 @@ class Atome
     # @language = :english
     # @callback = {}
     @tag = {}
+    @behavior = {}
     @selected = false
     #@metrics = {}
     @unit = {}
@@ -44,7 +47,7 @@ class Atome
     @int8 = {}
     @css = {}
     @aid = identity_generator
-
+    @controller_proc=[]
     @id = new_atome[:id] || @aid
     Universe.atomes.each do |_aid,atome_f|
       # we affect the already existing atome to target

data/lib/atome/extensions/atome.rb

@@ -51,6 +51,10 @@ module ObjectExtension
       #     alert option
       #     bloc.call(option)
       #   end
+    elsif params.key?(:molecule)
+      molecule=params[:molecule]
+      Genesis.build_molecule(molecule, &bloc)
+      Universe.add_to_molecule_list(molecule)
     end
     super if defined?(super)
   end
@@ -156,6 +160,10 @@ class Object
     grab(:view).box(params, &proc)
   end
 
+  # def intuition(params = {}, &proc)
+  #   grab(:view).intuition(params, &proc)
+  # end
+
   def circle(params = {}, &proc)
     grab(:view).circle(params, &proc)
   end
@@ -661,6 +669,11 @@ class CssProxy
     @current_atome.instance_variable_get('@css').to_s
   end
 
+  def receptor(msg, &bloc)
+    parsed = JSON.parse(msg)
+    bloc.call(parsed)
+  end
+
 end
 
 

data/lib/atome/genesis/genesis.rb

@@ -50,6 +50,12 @@ class Genesis
       new_atome(atome_name, &atome_proc)
 
     end
+    def build_molecule(molecule_name, &molecule_proc)
+      new_molecule(molecule_name, &molecule_proc)
+    end
+
+
+
 
     def auto_render_generator(element)
       Universe.renderer_list.each do |render_engine|
@@ -193,6 +199,74 @@ class Genesis
 
     end
 
+    def new_molecule(molecule, &method_proc)
+
+      Molecule.define_method molecule do |params, &user_proc|
+        m= instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
+        m
+      end
+
+
+
+      # # the method define below is the slowest but params are analysed and sanitized
+      # Atome.define_method element do |params = nil, &user_proc|
+      #   instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
+      #   if params
+      #     params = atome_sanitizer(element, params, &user_proc)
+      #     atome_processor(element, params, &user_proc)
+      #   else
+      #     # when no params passed whe assume teh user want a getter,
+      #     # as getter should give us all atome of a given within the atome
+      #     # ex : puts a.shape => return all atome with the type 'shape' in this atome
+      #     collected_atomes = []
+      #     # attached.each do |attached_atome|
+      #     #   collected_atomes << attached_atome if grab(attached_atome).type.to_sym == element.to_sym
+      #     # end
+      #     # TODO : add category for atome( material/physical vs modifier : color, shadow, .. vs shape, image ..)
+      #     # then add condition same things fo code in presets/atome atome_common
+      #     if %i[color shadow paint border].include?(element)
+      #       # we do the same for apply to be able to retrieve 'color' and other atome that apply instead of being attached
+      #       @apply.each do |attached_atome|
+      #         collected_atomes << attached_atome if grab(attached_atome).type.to_sym == element.to_sym
+      #       end
+      #     else
+      #       # collected_atomes = attached
+      #       # if @attached
+      #       attached.each do |attached_atome|
+      #         collected_atomes << attached_atome if grab(attached_atome).type.to_sym == element.to_sym
+      #       end
+      #       # end
+      #
+      #     end
+      #     # TODO/ FIXME : potential problem with group  here"
+      #     # group({ collect: collected_atomes })
+      #     collected_atomes
+      #   end
+      # end
+      #
+      # # the method define below is the fastest params are passed directly
+      # Atome.define_method "set_#{element}" do |params, &user_proc|
+      #   # we generate the corresponding module here:
+      #   # Object.const_set(element, Module.new)
+      #   # we add the newly created atome to the list of "child in it's category, eg if it's a shape we add the new atome
+      #   # to the shape particles list : @!atome[:shape] << params[:id]
+      #   # Atome.new(params, &user_proc)
+      #
+      #   if Universe.atomes[params[:id]]
+      #     # if atome id already exist we grab the previous one
+      #     # this prevent the creation of new atome if the atome already exist
+      #     previous_atome= grab(params[:id])
+      #     # now we must re-affect affected atomes
+      #     previous_atome.affect(params[:affect])
+      #     previous_atome
+      #   else
+      #     Atome.new(params, &user_proc)
+      #   end
+      #   # Now we return the newly created atome instead of the current atome that is the parent cf: b=box; c=b.circle
+      # end
+
+    end
+
   end
 
 end

data/lib/atome/genesis/particles/communication.rb

@@ -20,9 +20,7 @@ new({ particle: :message, category: :communication, type: :hash }) do |params, b
 
 end
 
-new({ particle: :controller, category: :communication, type: :hash }) do |msg|
-  Atome.controller_sender(msg)
-end
+
 
 new({ particle: :int8, category: :communication, type: :int })
 
@@ -30,4 +28,16 @@ new({ particle: :language, category: :communication, type: :string }) do |params
   @data = int8[params]
   params
 end
+# method below are used for communication with ntaive core
+def receptor(msg)
+  parsed = JSON.parse(msg)
+  A.controller_code[:controller].call(parsed)
+end
 
+new({ particle: :controller, category: :communication, type: :hash }) do |msg|
+  Atome.controller_sender(msg)
+end
+
+new({post: :controller}) do |_p, bloc|
+  @controller_proc << bloc
+end

data/lib/atome/genesis/particles/property.rb

@@ -134,4 +134,13 @@ new({particle: :inside, render: false})
 new({ initialized: :inside }) do |params, &user_proc|
   render(:inside, params, &user_proc)
 end
-new({ particle: :margin })
+new({ particle: :margin })
+
+new({ particle: :value }) do |val|
+  pro_f = behavior[:value]
+  instance_exec(val, &pro_f) if pro_f.is_a?(Proc)
+  val
+end
+
+
+new({ particle: :behavior })

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

@@ -234,4 +234,14 @@ new ({ particle: :css, category: :utility, type: :string })
 
 new({ read: :css }) do
   CssProxy.new(js, nil, self)
-end
+end
+
+new({particle: :holder, category: :utility, type: :atome})
+
+# this particle is mainly used in conjunction with alternate particle as a 'lambda' to alternate  methods
+new({particle: :executor, category: :utility, type: :hash}) do |params|
+  params.each do |method, opt|
+    send(method, opt)
+  end
+  params
+end

data/lib/atome/kernel/universe.rb

@@ -6,6 +6,7 @@ class Universe
   @atomes = {}
   @atomes_ids = {}
   @atome_list = []
+  @molecule_list = []
   @particle_list = {}
   @renderer_list = %i[html browser headless server log]
   @sanitizers = {}
@@ -24,7 +25,7 @@ class Universe
   @database_ready = false
   # @historicize=false
   class << self
-    attr_reader :atomes, :atomes_ids, :renderer_list, :atome_list, :particle_list, :classes, :counter, :atomes_specificities
+    attr_reader :atomes, :atomes_ids, :renderer_list,:molecule_list, :atome_list, :particle_list, :classes, :counter, :atomes_specificities
     attr_accessor :connected,:allow_sync, :allow_localstorage, :database_ready
 
     def messages
@@ -68,7 +69,8 @@ class Universe
     end
 
     def add_to_particle_list(particle = nil, type, category)
-      instance_variable_get('@particle_list')[particle] = { type: type, category: category }
+      # instance_variable_get('@particle_list')[particle] = { type: type, category: category }
+      @particle_list[particle] = { type: type, category: category }
     end
 
     def add_atomes_specificities atome_type_to_add
@@ -87,16 +89,22 @@ class Universe
 
     def add_sanitizer_method(method_name, &method_proc)
       # this method is used to add sanitizer methods
-      instance_variable_get('@sanitizers').merge!({ method_name => method_proc })
+      # instance_variable_get('@sanitizers').merge!({ method_name => method_proc })
+      @sanitizers.merge!({ method_name => method_proc })
     end
 
     def get_sanitizer_method(method_name)
       # this method is used to add optional methods
-      instance_variable_get('@sanitizers')[method_name]
+      # instance_variable_get('@sanitizers')[method_name]
+      @sanitizers[method_name]
     end
 
     def add_to_atome_list(atome)
-      instance_variable_get('@atome_list').push(atome)
+      @atome_list.push(atome)
+    end
+
+    def add_to_molecule_list(molecule)
+      @molecule_list.push(molecule)
     end
 
     def add_to_atomes(aid, atome)

data/lib/atome/presets/atome.rb

@@ -54,12 +54,17 @@ class Atome
   end
 
   def box(params = {}, &bloc)
-
     atome_preset = :box
     params = atome_common(atome_preset, params)
     preset_common(params, &bloc)
   end
 
+  # def intuition(params = {}, &bloc)
+  #   atome_preset = :intuition
+  #   params = atome_common(atome_preset, params)
+  #   preset_common(params, &bloc)
+  # end
+
   def circle(params = {}, &bloc)
     atome_preset = :circle
     params = atome_common(atome_preset, params)

data/lib/atome/utilities/essentials.rb

@@ -25,6 +25,9 @@ module Essentials
     box: { type: :shape, width: 39, height: 39,
            apply: [:box_color],
            left: 0, top: 0,  preset: :box },
+    # intuition: { type: :intuition, width: 39, height: 39,
+    #        apply: [:box_color],
+    #        left: 0, top: 0,  preset: :intuition },
     vector: { type: :vector, width: 39, height: 39,
               left: 0, top: 0,  preset: :vector, definition: corp },
     circle: { type: :shape, width: 39, height: 39, smooth: '100%',

data/lib/atome/version.rb

@@ -2,5 +2,5 @@
 
 #  return atome version
 class Atome
-  VERSION = '0.5.6.7.8'
+  VERSION = '0.5.6.8.3'
 end

data/lib/molecules/intuition/utillities.rb

@@ -1,78 +1,269 @@
 # frozen_string_literal: true
 
-module Molecule
-  def slider(params, &bloc)
-    attach_to = params[:attach] || :view
-    color_found = params[:color] ||= :gray
-    default_slider_particles = { color: color_found, width: 333, height: 33, left: 0, top: 0, smooth: 9 }
-    default_cursor_particles = { color: color_found, width: 29, height: 29, left: 0, smooth: '100%' }
-    cursor_found = params.delete(:cursor)
-    cursor_particle = default_cursor_particles.merge(cursor_found)
-    slider_particle = default_slider_particles.merge(params)
-    slider = grab(attach_to).box(slider_particle)
-    slider.shadow({
-                    id: :s2,
-                    left: 3, top: 3, blur: 9,
-                    invert: true,
-                    red: 0, green: 0, blue: 0, alpha: 0.7
-                  })
-    cursor_top = (slider_particle[:height] - cursor_particle[:height]) / 2.0
-    cursor = slider.box(cursor_particle)
-    bloc.call(cursor_particle[:left])
-    cursor.top(cursor_top)
-    cursor.shadow({
-                    id: :s4,
-                    left: 1, top: 1, blur: 3,
-                    option: :natural,
-                    red: 0, green: 0, blue: 0, alpha: 0.6
-                  })
-    cursor.drag({ restrict: { max: { left: slider_particle[:width] - cursor_particle[:width], top: cursor_top }, min: { top: cursor_top } } }) do |_event|
-      value = cursor.left.to_f / (slider_particle[:width] - cursor_particle[:width]) * 100
-      bloc.call(value)
+new(molecule: :input) do |params, bloc|
+  params[:height] ||= 15
+  params[:width] ||= 222
+  trigger = params.delete(:trigger)
+  trigger ||= :return
+  limit = params.delete(:limit)
+  limit ||= 15
+  back_col = params.delete(:back)
+  back_col ||= :grey
+  text_col = params.delete(:text)
+  text_col ||= :black
+  default_text = params.delete(:default)
+  default_text ||= :input
+  default_parent = if self.instance_of?(Atome)
+                     id
+                   else
+                     :view
+                   end
+  attach_to = params[:attach] || default_parent
+  renderer_found = grab(attach_to).renderers
+  input_back = Atome.new(
+    { renderers: renderer_found, type: :shape, color: back_col,
+      left: 0, top: 0, data: '', attach: attach_to,
+      smooth: 6, overflow: :hidden,
+    })
+
+  text_input = Atome.new(
+    { renderers: [:html], type: :text, color: text_col, component: { size: params[:height] },
+      data: default_text, left: params[:height] * 20 / 100, top: 0, edit: true, attach: input_back.id, height: params[:height],
+      position: :absolute
+    }
+  )
+
+  text_input.touch(:down) do
+    text_input.edit(true)
+  end
+
+  text_input.keyboard(:down) do |native_event|
+    # text_input.component({ selected: { color: :red, text: :red } })
+
+    event = Native(native_event)
+    if event[:keyCode].to_s == '8' || event[:keyCode].to_s == '46'
+      # always allow
+    elsif event[:keyCode].to_s == '13'
+      # we prevent the input
+      if trigger == :return
+        bloc.call(text_input.data)
+      end
+      text_input.edit(false)
+      event.preventDefault()
+    elsif text_input.data.length > limit
+      event.preventDefault()
+    end
+    if trigger == :down
+      bloc.call(text_input.data)
     end
-    slider
   end
 
-  def list(params)
-    styles_found = params.delete(:styles)
-    element = params.delete(:element)
-    listing = params.delete(:listing)
-
-    styles_found ||= {
-      width: 99,
-      height: 33,
-      margin: 6,
-      shadow: { blur: 9, left: 3, top: 3, id: :cell_shadow, red: 0, green: 0, blue: 0, alpha: 0.6 },
-      left: 0,
-      color: :yellowgreen
-    }
-    element ||= { width: 33,
-                  height: 33,
-                  left: :center,
-                  top: :center,
-                  color: :orange,
-                  type: :text }
-    unless params[:width]
-      params[:width] = styles_found[:width]
+  text_input.keyboard(:up) do |native_event|
+    input_back.data = text_input.data
+    if trigger == :up
+      bloc.call(text_input.data)
+    end
+  end
+  params.each do |part_f, val_f|
+    input_back.send(part_f, val_f)
+  end
+  input_back.holder(text_input)
+  input_back
+end
+new(molecule: :list) do |params, _bloc|
+
+  styles_found = params.delete(:styles)
+  element = params.delete(:element)
+  listing = params.delete(:listing)
+
+  styles_found ||= {
+    width: 99,
+    height: 33,
+    margin: 6,
+    shadow: { blur: 9, left: 3, top: 3, id: :cell_shadow, red: 0, green: 0, blue: 0, alpha: 0.6 },
+    left: 0,
+    color: :yellowgreen
+  }
+  element ||= { width: 33,
+                height: 33,
+                left: :center,
+                top: :center,
+                color: :orange,
+                type: :text }
+  unless params[:width]
+    params[:width] = styles_found[:width]
+  end
+  unless element[:width]
+    element[:width] = styles_found[width]
+  end
+  margin = styles_found[:margin]
+  height_found = styles_found[:height]
+
+  # lets create the listing container
+  default_parent = if self.instance_of?(Atome)
+                     id
+                   else
+                     :view
+                   end
+  attach_to = params[:attach] || default_parent
+  renderer_found = grab(attach_to).renderers
+  list = Atome.new({ renderers: renderer_found, type: :shape,  color: { alpha: 0 }, attach: attach_to }.merge(params))
+  # Atome.new(
+  #     { renderers: [:html], type: :shape, attach: :view, color: back_col,
+  #       left: 0, top: 0, data: '', attach: attach_to,
+  #       smooth: 6, overflow: :hidden,
+  #     })
+  # now the listing
+  listing.each_with_index do |data, index|
+    # let's create the container
+    new_atome = { renderers: renderer_found, attach: list.id }.merge(styles_found).merge({ type: :shape })
+    el = Atome.new(new_atome)
+    el.top((height_found + margin) * index)
+    # now the content
+    Atome.new({ renderers: renderer_found, attach: el.id }.merge(element).merge(data))
+
+  end
+  list
+end
+new({ molecule: :slider }) do |params, bloc|
+
+  default_value = params[:value] ||= 0
+  orientation = params.delete(:orientation) || :horizontal
+  range_found = params.delete(:range)
+  min_value = params.delete(:min) || 0
+  max_value = params.delete(:max) || 100
+  color_found = params[:color] ||= :gray
+  default_smooth = 9
+  default_slider_particles = { color: color_found, width: 333, height: 33, left: 0, top: 0, smooth: default_smooth }
+  default_cursor_particles = { color: color_found, width: 29, height: 29, left: 0, smooth: '100%' }
+  cursor_found = params.delete(:cursor)
+  slider_particle = default_slider_particles.merge(params)
+  slider = box(slider_particle)
+
+  slider_shadow = slider.shadow({
+                                  id: :s2,
+                                  left: 3, top: 3, blur: 9,
+                                  invert: true,
+                                  red: 0, green: 0, blue: 0, alpha: 0.7
+                                })
+
+  range = slider.box({ id: "#{slider.id}_range", top: :auto, bottom: 0 })
+
+  if range_found
+    range.apply(slider_shadow.id,)
+    range_found.each do |part, val|
+      range.send(part, val)
     end
-    unless element[:width]
-      element[:width] = styles_found[width]
+  else
+    range.color({ alpha: 0 })
+  end
+  cursor_particle = default_cursor_particles.merge(cursor_found).merge({ id: "#{slider.id}_cursor" })
+  cursor = slider.box(cursor_particle)
+  cursor_left = (slider_particle[:width] - cursor_particle[:width]) / 2.0
+  cursor_top = (slider_particle[:height] - cursor_particle[:height]) / 2.0
+
+  my_behavior = lambda() do |new_value|
+    if orientation == :vertical
+      if cursor.width < slider.width
+        range.width(cursor.width)
+        range.left(cursor_left)
+      else
+        range.width(slider.width)
+        range.smooth(default_smooth)
+      end
+      cursor_top_initial = ((max_value - new_value).to_f / (max_value - min_value)) * (slider_particle[:height] - cursor_particle[:height])
+      bloc.call(new_value)
+      slider.instance_variable_set('@value',new_value)
+      cursor.top(cursor_top_initial)
+      cursor.left(cursor_left)
+      range.height((slider.height - cursor.top) - cursor.height / 2)
+    else
+      if cursor.height < slider.height
+        range.height(cursor.height)
+        range.top(cursor_top)
+      else
+        range.height(slider.height)
+        range.smooth(default_smooth)
+      end
+      cursor_left_initial = ((new_value - min_value).to_f / (max_value - min_value)) * (slider_particle[:width] - cursor_particle[:width])
+      bloc.call(new_value)
+      slider.instance_variable_set('@value',new_value)
+      cursor.left(cursor_left_initial)
+      cursor.top(cursor_top)
+      range.width(cursor.left + cursor.width / 2)
     end
-    margin = styles_found[:margin]
-    height_found = styles_found[:height]
-    renderer_found = renderers
-    # lets create the listing container
-    list = box({ attach: id, color: { alpha: 0 } }.merge(params))
-    # now the listing
-    listing.each_with_index do |data, index|
-      # let's create the container
-      new_atome = { renderers: renderer_found, attach: list.id }.merge(styles_found).merge({ type: :shape })
-      el = Atome.new(new_atome)
-      el.top((height_found + margin) * index)
-      # now the content
-      Atome.new({ renderers: renderer_found, attach: el.id }.merge(element).merge(data))
+  end
+  slider.behavior({ value: my_behavior })
 
+  update_value = lambda do |cursor_position, cursor_size, slider_size, orientation|
+    effective_slider_size = slider_size - cursor_size
+    if orientation == :vertical
+      percentage = 1.0 - (cursor_position.to_f / effective_slider_size)
+    else
+      percentage = cursor_position.to_f / effective_slider_size
     end
-    list
+    value_range = max_value - min_value
+    calculated_value = min_value + (value_range * percentage).round
+    calculated_value.clamp(min_value, max_value)
   end
+
+  if orientation == :vertical
+    if cursor.width < slider.width
+      range.width(cursor.width)
+      range.left(cursor_left)
+    else
+      range.width(slider.width)
+      range.smooth(default_smooth)
+    end
+
+    cursor_top_initial = ((max_value - default_value).to_f / (max_value - min_value)) * (slider_particle[:height] - cursor_particle[:height])
+    bloc.call(default_value)
+    cursor.top(cursor_top_initial)
+    cursor.left(cursor_left)
+    range.height((slider.height - cursor.top) - cursor.height / 2)
+    # now the event
+    cursor.drag({ restrict: { max: { top: slider_particle[:height] - cursor_particle[:height], left: cursor_left }, min: { left: cursor_left } } }) do |event|
+      value = update_value.call(cursor.top, cursor_particle[:height], slider_particle[:height], orientation)
+      range.height((slider.height - cursor.top) - cursor.height / 2)
+      bloc.call(value)
+      slider.instance_variable_set('@value',value)
+    end
+
+  else
+
+    if cursor.height < slider.height
+      range.height(cursor.height)
+      range.top(cursor_top)
+    else
+      range.height(slider.height)
+      range.smooth(default_smooth)
+    end
+
+    cursor_left_initial = ((default_value - min_value).to_f / (max_value - min_value)) * (slider_particle[:width] - cursor_particle[:width])
+    bloc.call(default_value)
+    cursor.left(cursor_left_initial)
+    cursor.top(cursor_top)
+    range.width(cursor.left + cursor.width / 2)
+
+    # now the event
+    cursor.drag({ restrict: { max: { left: slider_particle[:width] - cursor_particle[:width], top: cursor_top }, min: { top: cursor_top } } }) do |event|
+      value = update_value.call(cursor.left, cursor_particle[:width], slider_particle[:width], orientation)
+      range.width(cursor.left + cursor.width / 2)
+      bloc.call(value)
+      slider.instance_variable_set('@value',value)
+    end
+  end
+  cursor.touch(:double) do
+    slider.value(default_value)
+  end
+
+  cursor.shadow({
+                  id: :s4,
+                  left: 1, top: 1, blur: 3,
+                  option: :natural,
+                  red: 0, green: 0, blue: 0, alpha: 0.6
+                })
+  slider
+
 end
+new({ particle: :behavior })

data/lib/renderers/html/html.rb

@@ -25,6 +25,7 @@ class HTML
     @id = id_found
     @original_atome = current_atome
     @touch_removed = {}
+
   end
 
   def object

data/vendor/assets/application/examples/alternate.rb

@@ -1,4 +1,14 @@
 # frozen_string_literal: true
+def act_on(obj)
+  obj.color(:red)
+  obj.left(56)
+end
+
+def act_off(obj)
+  obj.color(:blue)
+  obj.left(33)
+end
+
 
 b = box({ left: 12, id: :the_first_box, top: 30 })
 
@@ -6,7 +16,7 @@ b.touch(true) do
   b.alternate({ width: 33, color: :red, height: 33 , smooth: 0 }, { width: 66, color: :orange, blur: 8}, { height: 66, color: :green, smooth: 9, blur: 0})
 end
 
-c = circle({ left: 333 , top: 30})
+c = circle({ left: 99 , top: 30})
 
 c.touch(true) do
   alt = b.alternate(true, false)
@@ -15,4 +25,12 @@ c.touch(true) do
   else
     c.color(:orange)
   end
-end
+end
+
+
+c2 = circle({ left: 333 , top: 30})
+
+
+c2.touch(true) do
+  b.alternate({  executor: {act_on: b}  }, { executor: {act_off: b}})
+end

data/vendor/assets/application/examples/behavior.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Behaviors allow you to add specific code to any particle, enabling the particle to behave differently.
+# Here, when the first box receives a value, it behaves differently from the second box even if they received
+# the same params .
+
+text({ data: :hello, id: :the_txt, left: 120 })
+
+b=box
+
+my_lambda= lambda do |new_value|
+  grab(:the_txt).color(:red)
+end
+
+b.behavior({value: my_lambda})
+
+my_second_lambda= lambda do |new_value|
+  grab(:the_txt).data('from cirle')
+end
+c=box({top: 69})
+c.behavior({value: my_second_lambda})
+
+wait 1 do
+  c.value(:ok)
+end
+wait 2 do
+  b.value(:ok)
+end
+
+
+
+

data/vendor/assets/application/examples/executor.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+def act_on(obj)
+  obj.color(:red)
+  obj.left(56)
+end
+
+def act_off(obj)
+  obj.color(:blue)
+  obj.left(33)
+end
+
+
+b = box({ left: 12, id: :the_first_box, top: 30 })
+
+b.touch(true) do
+  b.alternate({ width: 33, color: :red, height: 33 , smooth: 0 }, { width: 66, color: :orange, blur: 8}, { height: 66, color: :green, smooth: 9, blur: 0})
+end
+
+c = circle({ left: 99 , top: 30})
+
+c.touch(true) do
+  alt = b.alternate(true, false)
+  if alt
+    c.color(:yellowgreen)
+  else
+    c.color(:orange)
+  end
+end
+
+
+c2 = circle({ left: 333 , top: 30})
+
+
+c2.touch(true) do
+  b.alternate({  executor: {act_on: b}  }, { executor: {act_off: b}})
+end

data/vendor/assets/application/examples/holder.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+# holder is a particle that contain an atome so we use my_objet.holder.left(33)
+# and it will move the atome contain in the holder particle to be manipulated
+# it facilitate the access of some atome without being worried about their id
+# this is mainly used int context of input , slider , etc...
+
+
+# simple example
+b=box({color: :black})
+
+c=b.circle({width: 10, height: 10, color: :red})
+
+b.holder(c)
+wait 1 do
+  b.holder.center(true)
+end
+
+
+
+
+
+
+# second example ( holder is build in the input molecule)
+text({ left: 33, top: 33, data: 'data collected', id: :infos })
+
+inp = A.input({ width: 166,
+                trigger: :up,
+                back: :orange,
+                shadow: {
+                  id: :s2,
+                  left: 3, top: 3, blur: 3,
+                  invert: true,
+                  red: 0, green: 0, blue: 0, alpha: 0.9
+                },
+                text: :black,
+                smooth: 3,
+                left: 66,
+                top: 33,
+                default: 'type here'
+              }) do |val|
+
+  grab(:infos).data(val)
+end
+
+wait 2 do
+  inp.top(12)
+  wait 1 do
+    inp.width(666)
+    inp.holder.blur(6)
+    wait 1 do
+      inp.holder.blur(0)
+      inp.holder.data('injected data')
+    end
+  end
+
+end
+
+
+
+
+
+

data/vendor/assets/application/examples/input.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+t = text({ left: 33, top: 33, data: 'data collected', id: :infos })
+
+inp=input({ width: 166,
+              trigger: :up,
+              back: :orange,
+              shadow: {
+                id: :s2,
+                left: 3, top: 3, blur: 3,
+                invert: true,
+                red: 0, green: 0, blue: 0, alpha: 0.9
+              },
+              attach: :intuition,
+              text: :black,
+              smooth: 3,
+              left: 66,
+              top: 33,
+              default: 'type here'
+            }) do |val|
+
+  grab(:infos).data(val)
+end
+
+inp.top(12)
+
+  wait 1 do
+    inp.width(666)
+    wait 1 do
+      inp.holder.data('new data')
+    end
+end
+
+
+
+

data/vendor/assets/application/examples/list.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 styles = {
   width: 199,
   height: 33,
@@ -24,11 +23,13 @@ listing = [
   { data: :hi },
   { data: :ho }
 ]
-
-list_1 = A.list({
+b=box({drag: true})
+list_1 = grab(:intuition).list({
                   styles: styles,
                   element: element,
-                  listing: listing
+                  listing: listing,
+                               left: 33,
+                  attach: b.id
                 })
 
 # test2

data/vendor/assets/application/examples/sliders.rb

@@ -1,6 +1,17 @@
 # frozen_string_literal: true
-label=text({data: 0, top: 69, left: 69,attach:  :intuition, component: { size: 12 }, color: :gray})
 
-A.slider({width: 333} ) do |value|
+label = text({ data: 0, top: 400, left: 69, component: { size: 12 }, color: :gray })
+
+aaa = grab(:intuition).slider({ id: :toto, range: { color: :yellow }, min: -12, max: 33, width: 333, value: 12, height: 25, left: 99, top: 350, color: :orange, cursor: { color: :orange, width: 25, height: 25 } }) do |value|
+  label.data("(#{value})")
+end
+
+aa = grab(:intuition).slider({ orientation: :vertical, range: { color: :white }, value: 55, width: 55, height: 555, attach: :intuition, left: 555, top: 33, color: :red, cursor: { color: {alpha: 1, red: 0.12, green: 0.12, blue: 0.12}, width: 33, height: 66, smooth: 3 } }) do |value|
   label.data("(#{value})")
 end
+
+b=box
+b.touch(true) do
+  aa.value(12)
+  aaa.value(-6)
+end

data/vendor/assets/src/js/atome/atome_helpers/communication.js

@@ -29,7 +29,7 @@
 // }
 
 
-function controller_message(msg) {
-    // let json_msgs = JSON.parse(msg);
-    rubyVMCallback("A.receptor("+msg+")")
-}
+// function controller_message(msg) {
+//     // let json_msgs = JSON.parse(msg);
+//     rubyVMCallback("A.receptor("+msg+")")
+// }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atome
 version: !ruby/object:Gem::Version
-  version: 0.5.6.7.8
+  version: 0.5.6.8.3
 platform: ruby
 authors:
 - Jean-Eric Godard
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-16 00:00:00.000000000 Z
+date: 2024-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: artoo
@@ -540,6 +540,7 @@ files:
 - vendor/assets/application/examples/attach.rb
 - vendor/assets/application/examples/attached.rb
 - vendor/assets/application/examples/basic_understanding.rb
+- vendor/assets/application/examples/behavior.rb
 - vendor/assets/application/examples/blur.rb
 - vendor/assets/application/examples/border.rb
 - vendor/assets/application/examples/browse.rb
@@ -569,6 +570,7 @@ files:
 - vendor/assets/application/examples/encode.rb
 - vendor/assets/application/examples/encrypt.rb
 - vendor/assets/application/examples/example.rb
+- vendor/assets/application/examples/executor.rb
 - vendor/assets/application/examples/file.rb
 - vendor/assets/application/examples/fill.rb
 - vendor/assets/application/examples/find.rb
@@ -581,11 +583,13 @@ files:
 - vendor/assets/application/examples/help.rb
 - vendor/assets/application/examples/hierarchy.rb
 - vendor/assets/application/examples/history.rb
+- vendor/assets/application/examples/holder.rb
 - vendor/assets/application/examples/hypertext.rb
 - vendor/assets/application/examples/image.rb
 - vendor/assets/application/examples/import.rb
 - vendor/assets/application/examples/increment.rb
 - vendor/assets/application/examples/infos.rb
+- vendor/assets/application/examples/input.rb
 - vendor/assets/application/examples/int8.rb
 - vendor/assets/application/examples/js&ruby.rb
 - vendor/assets/application/examples/keyboard.rb