atome 0.5.6.4.8 → 0.5.6.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc73dbaea0b164408d4656f53afb29c6f207d7a3a9238d7e0f017fee5d99c76a
-  data.tar.gz: 97860122c2abfec80d74880bd80e24d3c4fb2bab39661aaf3d97e7d6bc1528b3
+  metadata.gz: 40ed4954cd1a97e3ebffa9a25d44de095ea8f1b825b91abab913ce9cf61535f6
+  data.tar.gz: c6da10feae807b7e738065951de242abfd3dcb31558552d2f47135bd41e67433
 SHA512:
-  metadata.gz: bd5524c4909dd4c276c9af722af86b5eaa1505f82ff6503737a5cd6e50e62009bb8be7e7cd82db7e482e7f18e7beb7e1339c2728fbb211f96060b60143f3e136
-  data.tar.gz: b485ea4522218c293c36f92e79caeb22fb9233e6146cbeb7271d9b328e2be809a86268871338bc49b4ba105352878f3d4ea99361cb7d41b122b46e37e2bb4fac
+  metadata.gz: 496ec64689699de33f6538034ba9ace545628ae2fcaa996521c747ffbb89d86461de0ac35580052d93ed1feb0518954cefc2e07afd6cab33f672ea44785ea299
+  data.tar.gz: 102a1c8266be193f3781154a597c1715e906e1da63f7df1e070e50c399f078a651947bc5f39d5f4f3a9423833fc0a7966dada61dc1199d280f086061dbe1bdce

data/lib/atome/atome.rb

@@ -4,7 +4,7 @@
 class Atome
   include Essentials
 
-  def aid(_v=nil)
+  def aid(_v = nil)
     @aid
   end
 
@@ -22,36 +22,36 @@ class Atome
     #   alert "atome found : #{ grab(new_atome[:id])}"
     #    grab(new_atome[:id])
     # else
-      # the keys :renderers, :type and :id should be placed in the first position in the hash
-      @history = {}
-      # @language = :english
-      # @callback = {}
-      @tag = {}
-      @selected = false
-      #@metrics = {}
+    # the keys :renderers, :type and :id should be placed in the first position in the hash
+    @history = {}
+    # @language = :english
+    # @callback = {}
+    @tag = {}
+    @selected = false
+    #@metrics = {}
     @unit = {}
-      @apply = []
-      @collect = {}
-      @collect = {}
-      @int8= {}
-      @css = {}
-      @aid =  identity_generator
-      Universe.add_to_atomes( @aid, self)
-      @id = new_atome[:id] || @aid
-      Universe.id_to_aid(@id,@aid)
-      @type = new_atome[:type] || :element
-      @attached = []
-      @category = []
-      # @display = { mode: :default }
-      # @backup={} # mainly used to restore particle when using grid /table /list display mode
-      @html = HTML.new(@id, self)
-      @headless = Headless.new(@id, self)
-      # now we store the proc in a an atome's property called :bloc
-      new_atome[:code] = atomes_proc if atomes_proc
-      # we reorder the hash
-      reordered_atome =reorder_particles(new_atome)
-      # FIXME : try to remove the condition below (it crash in the method :  def generator ... in genesis.rb)
-      collapse(reordered_atome)
+    @apply = []
+    @collect = {}
+    @int8 = {}
+    @css = {}
+    @aid = identity_generator
+    Universe.add_to_atomes(@aid, self)
+    @id = new_atome[:id] || @aid
+    Universe.id_to_aid(@id, @aid)
+    @type = new_atome[:type] || :element
+    @attached = []
+    @affect = []
+    @category = []
+    # @display = { mode: :default }
+    # @backup={} # mainly used to restore particle when using grid /table /list display mode
+    @html = HTML.new(@id, self)
+    @headless = Headless.new(@id, self)
+    # now we store the proc in a an atome's property called :bloc
+    new_atome[:code] = atomes_proc if atomes_proc
+    # we reorder the hash
+    reordered_atome = reorder_particles(new_atome)
+    # FIXME : try to remove the condition below (it crash in the method :  def generator ... in genesis.rb)
+    collapse(reordered_atome)
     # end
 
   end

data/lib/atome/genesis/atomes.rb

@@ -35,7 +35,8 @@ new({ sanitizer: :color }) do |params|
   params
 end
 # new({ post: :color }) do
-#   Atome.global_monitoring(self, [:red, :blue, :blue, :alpha, :left, :right, :diffusion], [:variable1, :variable2])
+#
+#   # Atome.global_monitoring(self, [:red, :blue, :blue, :alpha, :left, :right, :diffusion], [:variable1, :variable2])
 # end
 new({ atome: :image })
 new({ sanitizer: :image }) do |params|
@@ -54,7 +55,6 @@ new({ post: :image }) do
   instance_variable_set("@width", compute({ particle: :width })[:value])
   instance_variable_set("@height", compute({ particle: :height })[:value])
 end
-
 new({ atome: :video })
 new({ sanitizer: :video }) do |params|
   unless params.instance_of? Hash
@@ -69,23 +69,17 @@ new({ sanitizer: :video }) do |params|
 end
 new({ atome: :www })
 new({ atome: :shadow }) do |params|
-  # if params
-  #   if params.delete(:affect)
-  #     attach_value = params.delete(:affect)
-  #   else
-  #     attach_value=id
-  #   end
-  #
-  #   params[:affect] = attach_value
-  #   alert "=> params : #{params}"
-  #
-  # end
-
   if params
     attach_value = params.delete(:affect)
     params[:affect] = attach_value
   end
-  # alert "=> params : #{params}"
+  params
+end
+new({ atome: :border }) do |params|
+  if params
+    attach_value = params.delete(:affect)
+    params[:affect] = attach_value
+  end
   params
 end
 new({ atome: :raw })
@@ -130,7 +124,6 @@ end
 new({ atome: :machine })
 new({ atome: :paint })
 new({ atome: :vector })
-
 new({ atome: :matrix })
 new({ atome: :atomized, type: :hash })
 

data/lib/atome/genesis/genesis.rb

@@ -150,7 +150,7 @@ class Genesis
           # 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].include?(element)
+          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

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

@@ -2,9 +2,13 @@
 
 new({ particle: :smooth, category: :effect, type: :int })
 
-
 new({ particle: :blur, category: :effect, type: :int }) do |params|
-  # alert params
-  { value: params, affect: :self } unless params.instance_of?(Hash)
-  # params
-end
+  if affect.nil?
+      affect_to = affect
+  else
+    affect_to = [:self]
+  end
+  val= { value: params, affect: affect_to } unless params.instance_of?(Hash)
+  val
+end
+

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

@@ -2,9 +2,9 @@
 def detach_child(child)
   return unless child.attach
 
-    parent = grab(child.attach)
-    parent.attached.delete(@id)
-  
+  parent = grab(child.attach)
+  parent.attached.delete(@id)
+
 end
 
 # def detach_from_parent(parent_found, child_found)
@@ -50,14 +50,14 @@ new({ sanitizer: :attached }) do |children_ids|
 end
 
 new({ particle: :apply, category: :hierarchy, type: :string, render: false, store: false }) do |parents_ids, &user_proc|
-  # TODO: optimize the 2 lines below:
-  # html.reset_background
+
   @apply ||= []
   parents_ids = [parents_ids] unless parents_ids.instance_of?(Array)
   parents_ids.each do |parent_id|
     @apply.delete(parent_id)
     @apply << parent_id
   end
+  puts affect
   parents_ids = @apply
   children_ids = [id]
   parents_ids.each do |parent_id|
@@ -66,16 +66,13 @@ new({ particle: :apply, category: :hierarchy, type: :string, render: false, stor
     parent_found.instance_variable_set('@affect', []) unless parent_affect.instance_of? Array
     affect_element = parent_found.instance_variable_get('@affect')
     children_ids.each do |child_id|
-      # affect_element << child_id unless affect_element.include?(child_id)
       affect_element.delete(child_id)
-      # affect_element.push(child_id)
       affect_element << child_id
       child_found = grab(child_id)
       child_found&.render(:apply, parent_found, &user_proc)
     end
   end
   @apply = parents_ids
-
   parents_ids
 end
 
@@ -83,9 +80,9 @@ new({ particle: :affect, category: :hierarchy, type: :string, render: false }) d
   children_ids = [children_ids] unless children_ids.instance_of? Array
   children_ids.each do |child_id|
     child_found = grab(child_id)
-    #FIXME : found why it crash when removing the condition below
+    # FIXME : found why it crash when removing the condition below
     unless child_found.id == :black_matter
-      child_found.remove({all: :paint})
+      child_found.remove({ all: :paint })
     end
     child_found.apply([id], &user_proc)
   end

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

@@ -58,6 +58,10 @@ new({ post: :remove }) do |params|
       shadow.each do |atome_id_found|
         @apply.delete(atome_id_found)
       end
+    when :border
+      border.each do |atome_id_found|
+        @apply.delete(atome_id_found)
+      end
     else
       params.each do |particle, value|
         case particle
@@ -92,4 +96,21 @@ new({ sanitizer: :definition }) do |params|
 end
 
 new({ particle: :gradient, category: :material, type: :int })
-new({ particle: :border, category: :material, type: :int })
+
+new({ particle: :thickness, category: :material, type: :int })
+new({ after: :thickness}) do |params|
+  a=affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
+  a.each do |atome_to_refresh|
+    grab(atome_to_refresh).apply(id)
+  end
+  params
+end
+new({ particle: :pattern, category: :material, type: :string })
+new({ after: :pattern })do |params|
+  a=affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
+  a.each do |atome_to_refresh|
+    grab(atome_to_refresh).apply(id)
+  end
+  params
+end
+# new({ particle: :border, category: :material, type: :int })

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

@@ -7,24 +7,64 @@ def extract_rgb_alpha(color_string)
   blue = match_data[3].to_i
   alpha = match_data[4] ? match_data[4].to_f : nil
   { red: red, green: green, blue: blue, alpha: alpha }
+
 end
 
 new({ particle: :red, category: :property, type: :string }) do
+  # alert :ok
   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
   self
 end
+# FIXME  we have to apply both at post and after to make it work
+# used to refresh all affected atomes
+new({after: :red}) do |params|
+  a=affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
+  a.each do |atome_to_refresh|
+      grab(atome_to_refresh).apply(id)
+    end
+  params
+end
+
+
 new({ particle: :green, category: :property, type: :string }) do
   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
   self
 end
+
+# used to refresh all affected atomes
+new({after: :green}) do |params|
+  a=affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
+  a.each do |atome_to_refresh|
+    grab(atome_to_refresh).apply(id)
+  end
+  params
+end
+
 new({ particle: :blue, category: :property, type: :string }) do
   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
   self
 end
+
+# used to refresh all affected atomes
+new({after: :blue}) do |params|
+  a=affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
+  a.each do |atome_to_refresh|
+    grab(atome_to_refresh).apply(id)
+  end
+  params
+end
 new({ particle: :alpha, category: :property, type: :string }) do
   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
   self
 end
+# used to refresh all affected atomes
+new({after: :alpha}) do |params|
+  a=affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
+  a.each do |atome_to_refresh|
+    grab(atome_to_refresh).apply(id)
+  end
+  params
+end
 new({ particle: :diffusion, category: :property, type: :string }) do
   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
   self

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

@@ -90,3 +90,9 @@ new({ particle: :center, category: :spatial, type: :hash }) do |params|
   params = { x: 0, y: 0, dynamic: true } if params == true
   params
 end
+new ({ particle: :increment, category: :spatial, type: :hash }) do |params|
+  params.each do |particle, value|
+    prev_value=send(particle)
+    send(particle, value+prev_value)
+  end
+end

data/lib/atome/genesis/sparkle.rb

@@ -142,13 +142,19 @@ def atome_genesis
   atome_infos
   A.server({ address: 'localhost:9292', type: 'ws' })
   A.init_websocket do |msg|
-    puts "-3 #{msg}"
+    puts "websocket initailsaed #{msg}"
   end
 end
 
 def init_database # this method is call from JS (atome/communication) at WS connection
   # we init the db file eDen
-  A.message({ action: :init_db, data: { database: :eDen } }) do |_db_state|
+  A.sync({ action: :init_db, data: { database: :eDen } }) do |data|
+
+    if data[:data][:message] == 'database_ready'
+      Universe.database_ready = true
+    else
+      Universe.database_ready = false
+    end
   end
   # authentication : email, pass
   # atome : date, particles
@@ -156,36 +162,37 @@ def init_database # this method is call from JS (atome/communication) at WS conn
 
   particles = Universe.particle_list
   # now we populate the DB
-  A.message({ action: :crate_db_table, data: { table: :user } }) do |_db_state|
+  A.sync({ action: :crate_db_table, data: { table: :user } }) do |_db_state|
+    # puts "===> #{_db_state}"
   end
 
-  A.message({ action: :create_db_column, data: { table: :user, column: :email, type: :string } }) do |_db_state|
+  A.sync({ action: :create_db_column, data: { table: :user, column: :email, type: :string } }) do |_db_state|
   end
 
-  A.message({ action: :create_db_column, data: { table: :user, column: :password, type: :string } }) do |_db_state|
+  A.sync({ action: :create_db_column, data: { table: :user, column: :password, type: :string } }) do |_db_state|
   end
 
-  A.message({ action: :crate_db_table, data: { table: :history } }) do |_db_state|
+  A.sync({ action: :crate_db_table, data: { table: :history } }) do |_db_state|
   end
-  A.message({ action: :create_db_column, data: { table: :history, column: :aid, type: :string } }) do |_db_state|
+  A.sync({ action: :create_db_column, data: { table: :history, column: :aid, type: :string } }) do |_db_state|
   end
-  A.message({ action: :create_db_column, data: { table: :history, column: :particle, type: :string } }) do |_db_state|
+  A.sync({ action: :create_db_column, data: { table: :history, column: :particle, type: :string } }) do |_db_state|
   end
-  A.message({ action: :create_db_column, data: { table: :history, column: :value, type: :string } }) do |_db_state|
+  A.sync({ action: :create_db_column, data: { table: :history, column: :value, type: :string } }) do |_db_state|
   end
-  A.message({ action: :create_db_column, data: { table: :history, column: :date, type: :datetime } }) do |_db_state|
+  A.sync({ action: :create_db_column, data: { table: :history, column: :date, type: :datetime } }) do |_db_state|
   end
 
-  A.message({ action: :crate_db_table, data: { table: :atome } }) do |_db_state|
+  A.sync({ action: :crate_db_table, data: { table: :atome } }) do |_db_state|
   end
   particles.each do |particle, infos|
     type = infos[:type]
-    A.message({ action: :create_db_column, data: { table: :atome, column: particle, type: type } }) do |_db_state|
+    A.sync({ action: :create_db_column, data: { table: :atome, column: particle, type: type } }) do |_db_state|
     end
   end
 
   # now we send localstorage content to the server
-  puts  "now we send localstorage  send_localstorage_content to the server"
+  puts "now we send localstorage  send_localstorage_content to the server"
   send_localstorage_content
   # A.message({ action: :localstorage, data: get_localstorage_content }) do |_db_state|
   # end
@@ -194,11 +201,12 @@ end
 def user_login
   # user = Universe.current_user
   password = Black_matter.password
-  message({ action: :authentication, data: { email: 'jeezs@atome.one' } }) do |email|
+  sync({ action: :authentication, data: { email: 'jeezs@atome.one' } }) do |email|
     puts "email received : #{email}"
   end
-  message({ action: :authorization, data: { password: password } }) do |pass|
+  sync({ action: :authorization, data: { password: password } }) do |pass|
     puts "password received : #{pass}"
   end
 end
+
 # Universe.allow_history=true

data/lib/atome/kernel/universe.rb

@@ -11,18 +11,20 @@ class Universe
   @sanitizers = {}
   @specificities = {}
   @messages = {}
- @increment=0
+  @increment = 0
   @categories = %w[atome communication effect event geometry hierarchy identity material
                   property security spatial time utility ]
   @history = {}
   @users = {}
   @help = {}
   @example = {}
-  @allow_history= false
+  @allow_history = false
+  @database_ready = false
   # @historicize=false
   class << self
-    attr_reader :atomes,:atomes_ids, :renderer_list, :atome_list, :particle_list, :classes, :counter, :atomes_specificities
-    attr_accessor :allow_history
+    attr_reader :atomes, :atomes_ids, :renderer_list, :atome_list, :particle_list, :classes, :counter, :atomes_specificities
+    attr_accessor :allow_history, :database_ready
+
     def messages
       @messages
     end
@@ -124,11 +126,13 @@ class Universe
       end
       collected_id
     end
+
     def generate_uuid
-      uuid = SecureRandom.uuid.gsub('-','')
+      uuid = SecureRandom.uuid.gsub('-', '')
       formatted_time = Time.now.strftime("%Y%m%d%H%M%S")
       "#{uuid}#{formatted_time}"
     end
+
     def app_identity
       # each app hav its own identity, this allow to generate new user identities from the
       # unique_id = generate_unique_id_with_timestamp
@@ -237,11 +241,16 @@ class Universe
     end
 
     def historicize(id, operation, element, params)
-      if @allow_history
-        operation_timing= Time.now.strftime("%Y%m%d%H%M%S%3N")+@increment.to_s
-        @increment+=1
-        @increment=@increment%100
-        JS.global[:localStorage].setItem(operation_timing,"{ #{id} => { #{operation} => { #{element} => #{params} } }, sync: false }")
+
+      if @allow_history && @database_ready
+        # sync
+        A.sync({ action: :historicize, data: { table: :user } }) do |_db_state|
+          # puts "===> #{_db_state}"
+        end
+        operation_timing = Time.now.strftime("%Y%m%d%H%M%S%3N") + @increment.to_s
+        @increment += 1
+        @increment = @increment % 100
+        JS.global[:localStorage].setItem(operation_timing, "{ #{id} => { #{operation} => { #{element} => #{params} } }, sync: false }")
         @history[@history.length] = { operation_timing => { id => { operation => { element => params } }, sync: false, time: Time.now } }
       end
     end

data/lib/atome/presets/atome.rb

@@ -26,7 +26,7 @@ class Atome
     # condition to handle color/shadow/paint atomes that shouldn't be attach to view
     # TODO : add category for atome( material/physical vs modifier : color, shadow, .. vs shape, image ..)
     # then add condition same things fo code in genesis new_atome
-    if %i[color shadow paint].include?(atome_preset)
+    if %i[color shadow paint border].include?(atome_preset)
       unless params[:affect]
         params[:affect] = if @id == :view
                             [:black_matter]

data/lib/atome/{helpers → utilities}/essentials.rb

@@ -37,7 +37,8 @@ module Essentials
             apply: [:text_color],
             width: :auto, height: :auto, language: :english },
     drm: { type: :drm, attach: :black_matter },
-    shadow: { type: :shadow, red: 0, green: 0, blue: 0, alpha: 0 },
+    shadow: { type: :shadow, red: 0, green: 0, blue: 0, alpha: 1, blur: 3, left: 3, top: 3 },
+    border: { type: :border, red: 0, green: 0, blue: 0, alpha: 0, pattern: :solid, thickness: 6 },
     color: { type: :color, red: 0, green: 0, blue: 0, alpha: 1}
   }
 

data/lib/atome/{helpers → utilities}/utilities.rb

@@ -7,6 +7,8 @@ class Atome
   class << self
 
 
+
+
     def file_handler(parent, content, bloc)
       grab(parent).instance_exec(content, &bloc)
     end
@@ -303,11 +305,16 @@ class Atome
   end
 
   def refresh
+    # we get the current color because they will be removed
+    # prev_color=color
+    # alert color.class
     particles_found = to_hash
     particles_found.each do |particle_found, value_found|
       send(particle_found, value_found)
     end
-
+     color.each do |col|
+       apply(col)
+     end
   end
 
   def each(&proc)
@@ -449,6 +456,14 @@ class Atome
     puts "sanitizer temp patch when an atome is passed instead of an id"
     @id
   end
+
+  def sync(params, &bloc)
+    params = { data: params } unless params.instance_of? Hash
+    message_id= "msg_#{Universe.messages.length}"
+    params[:message_id]=message_id
+    Universe.store_messages({msg_nb:message_id, proc: bloc })
+    html.send_message(params)
+  end
 end
 
 

data/lib/atome/version.rb

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

data/lib/atome.rb

@@ -7,9 +7,9 @@ require 'atome/version'
 require 'atome/genesis/genesis'
 require 'atome/kernel/black_matter'
 require 'atome/kernel/universe'
-require 'atome/helpers/essentials'
+require 'atome/utilities/essentials'
 require 'renderers/renderer'
-require 'atome/helpers/color_helper/color'
+require 'atome/utilities/color_helper/color'
 require 'atome/extensions/atome'
 require 'atome/extensions/mathematics'
 require 'atome/atome'
@@ -28,12 +28,12 @@ require 'atome/genesis/particles/security'
 require 'atome/genesis/particles/spatial'
 require 'atome/genesis/particles/time'
 require 'atome/genesis/particles/utility'
-require 'atome/helpers/utilities'
-require 'atome/helpers/security'
+require 'atome/utilities/utilities'
+require 'atome/utilities/security'
 require 'renderers/html/index'
 require 'renderers/headless/index'
 require 'renderers/server/index'
-require 'atome/helpers/sanitizer'
+require 'atome/utilities/sanitizer'
 require 'atome/genesis/sparkle'
 require 'molecules/init'
 # require 'eVe/lib/eVe'

data/lib/atome_relative.rb

@@ -6,9 +6,9 @@ require_relative './atome/version'
 require_relative './atome/genesis/genesis'
 require_relative 'atome/kernel/black_matter'
 require_relative './atome/kernel/universe'
-require_relative './atome/helpers/essentials'
+require_relative './atome/utilities/essentials'
 require_relative './renderers/renderer'
-require_relative './atome/helpers/color_helper/color'
+require_relative './atome/utilities/color_helper/color'
 require_relative './atome/extensions/atome'
 require_relative './atome/extensions/mathematics'
 require_relative './atome/atome'
@@ -27,12 +27,12 @@ require_relative './atome/genesis/particles/security'
 require_relative './atome/genesis/particles/spatial'
 require_relative './atome/genesis/particles/time'
 require_relative './atome/genesis/particles/utility'
-require_relative './atome/helpers/utilities'
-require_relative './atome/helpers/security'
+require_relative './atome/utilities/utilities'
+require_relative './atome/utilities/security'
 require_relative './renderers/html/index_relative'
 require_relative './renderers/headless/index_relative'
 require_relative './renderers/server/index_relative'
-require_relative './atome/helpers/sanitizer'
+require_relative './atome/utilities/sanitizer'
 require_relative './atome/genesis/sparkle'
 require_relative './molecules/init'
 # require_relative './eVe/lib/eVe'

data/lib/renderers/html/effect.rb

@@ -27,3 +27,25 @@ new({ renderer: :html, method: :blur, type: :integer }) do |params, _user_proc|
       html.filter(:blur, "#{params[:value]}px")
     end
   end
+
+
+new({ renderer: :html, method: :blur, type: :integer, specific: :shadow }) do |params, _user_proc|
+  if params[:affect] == :back
+    html.backdropFilter(:blur, "#{params[:value]}px")
+  else
+    html.filter(:blur, "#{params[:value]}px")
+  end
+  # now we refresh if needed for dynamic refresh od affected atomes
+   affect(affect)
+end
+
+# new({ particle: :blur, category: :effect, type: :int , specific: :shadow}) do |params|
+#   alert :cool
+#   if affect.nil?
+#     affect_to = affect
+#   else
+#     affect_to = [:self]
+#   end
+#   val= { value: params, affect: affect_to } unless params.instance_of?(Hash)
+#   val
+# end

data/lib/renderers/html/hierarchy.rb

@@ -38,7 +38,6 @@ new({ renderer: :html, method: :apply, type: :string }) do |parent_found, _user_
     alpha = parent_found.alpha
     html.style(:backgroundColor, "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
@@ -75,6 +74,17 @@ new({ renderer: :html, method: :apply, type: :string }) do |parent_found, _user_
     # 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

data/lib/renderers/html/material.rb

@@ -52,16 +52,24 @@ new({ method: :remove, renderer: :html, type: :string }) do |object_id_to_remove
   end
 end
 
+# new({ method: :border, type: :hash, renderer: :html }) do |value, _user_proc|
+#   thickness = value[:thickness] || 5
+#   type = value[:pattern] || :solid
+#
+#   if value[:color].instance_of? Atome
+#     color_found = value[:color]
+#   else
+#     color_found = grab('black_matter').color(value[:color])
+#   end
+#
+#   red = color_found.red * 255
+#   green = color_found.green * 255
+#   blue = color_found.blue * 255
+#   alpha = color_found.alpha
+#
+#   html.style(:border, "#{type} #{thickness}px rgba(#{red},#{green},#{blue},#{alpha})")
+# end
+new({ method: :thickness, type: :integer, renderer: :html})
 
-new({ method: :border, type: :hash, renderer: :html }) do |value, _user_proc|
-  thickness = value[:thickness] || 5
-  type = value[:pattern] || :solid
-  color = if value[:color]
-            color_found = value[:color]
-            "#{color_found.red * 255},#{color_found.green * 255},#{color_found.blue * 255},#{color_found.alpha} "
-          else
-            "0,0,0,1"
-          end
-
-  html.style(:border, "#{type} #{thickness}px rgba(#{color})")
-end
+# end
+new({ method: :pattern, type: :integer, renderer: :html})

data/lib/renderers/html/property.rb

@@ -22,33 +22,6 @@ new({ renderer: :html, method: :edit }) do |params|
   html.update_data(params)
 end
 
-new({ method: :border, type: :hash, renderer: :html }) do |value, _user_proc|
-  thickness = value[:thickness] || 5
-  type = value[:pattern] || :solid
-  # color = if value[:color]
-  #           color_found = value[:color]
-  #           "#{color_found.red * 255},#{color_found.green * 255},#{color_found.blue * 255},#{color_found.alpha} "
-  #         else
-  #           "0,0,0,1"
-  #         end
-  if value[:color].instance_of? Atome
-    color_found= value[:color]
-  else
-    color_found=grab('black_matter').color(value[:color])
-  end
-
-    # alert "atome found 2 : #{color_found}"
-  red =  color_found.red* 255
-  green =  color_found.green* 255
-  blue =  color_found.blue* 255
-  alpha =  color_found.alpha
-  # alert "rgba(#{red},#{green},#{blue},#{alpha})"
-  #       color_found=    "#{1 * 255},#{color_found.green * 255},#{0 * 255},#{0.3} "
-
-  html.style(:border, "#{type} #{thickness}px rgba(#{red},#{green},#{blue},#{alpha})")
-  # html.style(:border, "#{type} #{thickness}px rgba(#{color_found})")
-  # html.style(:border, "solid 12px rgba(255, 255, 120, 0,3)")
-end
 
 new({ method: :clean, renderer: :html, type: :hash }) do |params|
   html.table_clean(params)

data/lib/renderers/html/spatial.rb

@@ -9,6 +9,7 @@ new({ method: :top, type: :integer, renderer: :html }) do |params|
   unit = @unit[:top] || :px if params.is_a? Numeric
   js[:style][:top] = "#{params}#{unit}"
 end
+
 new({ method: :bottom, type: :integer, renderer: :html }) do |params|
   unit = @unit[:bottom] || :px if params.is_a? Numeric
   js[:style][:bottom] = "#{params}#{unit}"
@@ -20,7 +21,10 @@ new({ method: :right, type: :integer, renderer: :html }) do |params|
   js[:style][:right] = "#{params}#{unit}"
 end
 
-new({ method: :top, type: :integer, renderer: :html, specific: :shadow })
+new({ method: :top, type: :integer, renderer: :html, specific: :shadow }) do
+  # now we refresh if needed for dynamic refresh od affected atomes
+  affect(affect)
+end
 
 # new({ method: :top, type: :integer, renderer: :html, specific: :text }) do |params|
 #   unit = @unit[:left] || :px
@@ -33,7 +37,10 @@ new({ method: :top, type: :integer, renderer: :html, specific: :shadow })
 
 new({ method: :left, type: :integer, specific: :color, renderer: :html })
 
-new({ method: :left, type: :integer, renderer: :html, specific: :shadow })
+new({ method: :left, type: :integer, renderer: :html, specific: :shadow }) do
+  # now we refresh if needed for dynamic refresh od affected atomes
+  affect(affect)
+end
 
 new({ method: :top, type: :integer, specific: :color, renderer: :html })
 

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

@@ -1,28 +1,59 @@
 # frozen_string_literal: true
 
-
-col=color({red: 1, green: 0.2, id: :the_col})
-c=circle
-b=box({left: 333})
-c2=circle({top: 190, width: 99, height: 99})
+# col=color({red: 1, green: 0.2, id: :the_col})
+c = circle({ id: :the_circle })
+b = box({ left: 333, id: :the_box })
+circle({ top: 190, width: 99, height: 99, id: :dont_break_too })
+c2 = circle({ top: 190, width: 99, height: 99, id: :dont_break })
 # let's add the border
-c2.border({ thickness: 5, color: :blue, pattern: :dotted })
-c.border({ thickness: 5, color: col, pattern: :dotted })
-b.border({ thickness: 5, color: col, pattern: :dotted })
-
 wait 1 do
-  c2.border({ thickness: 5, color: :green, pattern: :dotted })
-  c.border({ thickness: 5, color: :green, pattern: :dotted })
-  b.border({ thickness: 5, color: :green, pattern: :dotted })
+  c2.shadow({
+              # id: :s1,
+              # affect: [:the_circle],
+              left: 9,
+              top: 3,
+              blur: 9,
+              invert: false,
+              option: :natural,
+              red: 0, green: 0, blue: 0, alpha: 1
+            })
+  c2.border({ thickness: 5, red: 1, green: 0, blue: 0, alpha: 1, pattern: :dotted, id: :borderline })
 end
+c.border({ thickness: 5, red: 1, green: 1, blue: 0, alpha: 1, pattern: :dotted })
+b.border({ thickness: 5, red: 0, green: 1, blue: 0, alpha: 1, pattern: :dotted })
 
+wait 2 do
+  c2.border({ thickness: 5, red: 1, green: 1, blue: 0, alpha: 1, pattern: :solid })
+  c.border({ thickness: 5, red: 1, green: 1, blue: 0, alpha: 1, pattern: :dotted })
+  b.border({ thickness: 3, red: 1, green: 1, blue: 0, alpha: 1, pattern: :dotted })
+  b.text('touch me')
+end
+#
 b.touch(true) do
 
- b.border({ thickness: 5, color: { red: 1, green: 0 }, pattern: :dotted })
- puts  " no new atome added!, number of atomes: #{Universe.atomes.length}"
+  b.border({ thickness: 5, red: 1, green: 1, blue: 1, alpha: 1, pattern: :dotted, id: :the_door })
+  puts " no new atome added!, number of atomes: #{Universe.atomes.length}"
+  b.apply([:the_door])
+  c.apply([:the_door])
+  c2.apply([:the_door])
+  wait 1 do
+    # if the_door (border) is change all affect atomes are refreshed
+    grab(:the_door).pattern(:solid)
+    wait 1 do
+      # if the_door (border) is change all affect atomes are refreshed
+      grab(:the_door).thickness(20)
+      wait 1 do
+        # if the_door (border) is change all affect atomes are refreshed
+        grab(:the_door).red(0)
+        c2.color({alpha: 0})
+
+      end
+    end
+  end
 end
+
 # wait 6 do
-#   iamge(:red_planet)
+#   image(:red_planet)
 # end
 
 # # frozen_string_literal: true

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+cc=color({red: 1, blue: 0.1,id: :the_col})
+b=box({ left: 12, id: :the_first_box, apply: cc.id  })
+c=circle({ left: 99, top: 99 })
+
+wait 1 do
+  c.increment({left: 33, top: 99})
+  b.increment({left: 33, top: 99})
+  wait 1 do
+    c.increment({width: 33, top: -22})
+    b.increment({width: 33, top: -9})
+    cc.increment({red: -0.5})
+    wait 1 do
+      cc.increment({blue: 1})
+    end
+    # Atome.sync(:ok)
+  end
+end
+
+# wait 3 do
+#   color(:red)
+# end

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

@@ -22,12 +22,12 @@ def matrix(id, horizontal_nb, vertical_nb, spacing, size)
   end
   box_width = available_width / horizontal_nb
   box_height = available_height / vertical_nb
-
+  background=box({id: :background, width: 666, height: 666, color:{alpha: 0}})
   vertical_nb.times do |y|
     horizontal_nb.times do |x|
       id_generated = "#{id}_#{x}_#{y}"
       matrix_cells << id_generated
-      new_box = box({ id: id_generated })
+      new_box = background.box({ id: id_generated })
       new_box.width(box_width)
       new_box.height(box_height)
       new_box.left((box_width + spacing) * x + spacing)
@@ -142,4 +142,12 @@ test_cell.touch(true) do
   #   test_cell.color(:blue)
   # end
 
-end
+end
+wait 1 do
+  @current_matrix.width(33)
+end
+@current_matrix.drag(true)
+wait 2 do
+  grab(:background).left(666)
+  grab(:background).drag(true)
+end

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

@@ -34,7 +34,7 @@ wait 2 do
 end
 
 
-the_text = text({ data: 'text with shadow!', center: true, top: 222, width: 777, component: { size: 66 } })
+the_text = text({ data: 'text with shadow!', center: true, top: 222, width: 777, component: { size: 66 }, id: :my_text })
 
 
 the_text.shadow({
@@ -48,3 +48,13 @@ the_text.left(255)
 the_text.top(66)
 the_text.color(:red)
 
+wait 1 do
+  text_shadow= grab(:my_shadow)
+  text_shadow.alpha(0.5)
+  text_shadow.left(120)
+  text_shadow.blur({ value: 1 })
+
+  # grab(:my_text).refresh(true)
+
+end
+

data/vendor/assets/server/eDen.rb

@@ -85,11 +85,18 @@ class EDen
 
     end
 
+    def historicize(data, message_id)
+      # return test
+      # ws.send(return_message.to_json)
+      return { return: 'item to historicize  received', authorized: true, message_id: message_id }
+
+    end
+
     def init_db(_data, message_id)
       unless File.exist?("eden.sqlite3")
         Sequel.connect("sqlite://eden.sqlite3")
       end
-      { data: { message: 'database initialised' }, message_id: message_id }
+      { data: { message: 'database_ready' }, message_id: message_id }
     end
 
     def crate_db_table(data, message_id)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atome
 version: !ruby/object:Gem::Version
-  version: 0.5.6.4.8
+  version: 0.5.6.5.4
 platform: ruby
 authors:
 - Jean-Eric Godard
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-01 00:00:00.000000000 Z
+date: 2024-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: artoo
@@ -436,28 +436,27 @@ files:
 - lib/atome/genesis/particles/time.rb
 - lib/atome/genesis/particles/utility.rb
 - lib/atome/genesis/sparkle.rb
-- lib/atome/helpers/color_helper/color.rb
-- lib/atome/helpers/color_helper/color/cmyk.rb
-- lib/atome/helpers/color_helper/color/css.rb
-- lib/atome/helpers/color_helper/color/grayscale.rb
-- lib/atome/helpers/color_helper/color/hsl.rb
-- lib/atome/helpers/color_helper/color/palette.rb
-- lib/atome/helpers/color_helper/color/palette/adobecolor.rb
-- lib/atome/helpers/color_helper/color/palette/gimp.rb
-- lib/atome/helpers/color_helper/color/palette/monocontrast.rb
-- lib/atome/helpers/color_helper/color/rgb.rb
-- lib/atome/helpers/color_helper/color/rgb/colors.rb
-- lib/atome/helpers/color_helper/color/rgb/contrast.rb
-- lib/atome/helpers/color_helper/color/rgb/metallic.rb
-- lib/atome/helpers/color_helper/color/yiq.rb
-- lib/atome/helpers/essentials.rb
-- lib/atome/helpers/sanitizer.rb
-- lib/atome/helpers/security.rb
-- lib/atome/helpers/utilities.rb
 - lib/atome/kernel/black_matter.rb
-- lib/atome/kernel/ruby
 - lib/atome/kernel/universe.rb
 - lib/atome/presets/atome.rb
+- lib/atome/utilities/color_helper/color.rb
+- lib/atome/utilities/color_helper/color/cmyk.rb
+- lib/atome/utilities/color_helper/color/css.rb
+- lib/atome/utilities/color_helper/color/grayscale.rb
+- lib/atome/utilities/color_helper/color/hsl.rb
+- lib/atome/utilities/color_helper/color/palette.rb
+- lib/atome/utilities/color_helper/color/palette/adobecolor.rb
+- lib/atome/utilities/color_helper/color/palette/gimp.rb
+- lib/atome/utilities/color_helper/color/palette/monocontrast.rb
+- lib/atome/utilities/color_helper/color/rgb.rb
+- lib/atome/utilities/color_helper/color/rgb/colors.rb
+- lib/atome/utilities/color_helper/color/rgb/contrast.rb
+- lib/atome/utilities/color_helper/color/rgb/metallic.rb
+- lib/atome/utilities/color_helper/color/yiq.rb
+- lib/atome/utilities/essentials.rb
+- lib/atome/utilities/sanitizer.rb
+- lib/atome/utilities/security.rb
+- lib/atome/utilities/utilities.rb
 - lib/atome/version.rb
 - lib/atome_relative.rb
 - lib/molecules/examples/site.rb
@@ -568,6 +567,7 @@ files:
 - 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/int8.rb
 - vendor/assets/application/examples/keyboard.rb