atome 0.5.7.5.4 → 0.5.7.5.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfe68326ce8511009dd9226874a9478fed337b58b33914588569477c53fc5f60
-  data.tar.gz: f4c496a1eed0f0ca66a8a4cc742e83c962578fa6dd23f58af4a2dda0cf658d0e
+  metadata.gz: ed430053dc8b703ad1842ed461684e0018e271ef919dfcfc76f9b2f3fc225c63
+  data.tar.gz: 91e03aabb90fc5b616248b5a87dff16a16093d9697a931ae25282bd5bde9b2cc
 SHA512:
-  metadata.gz: 22530cfa45962c787536df528f4609511868ecd99994b9dd1fe9f83ceca55517d69a04ce86a0cb92663c030cab0693161b3940f20a6b220aaeb3acc907976dfa
-  data.tar.gz: cb0f7b157205cd44f2cb254f0b3808908f740268f9dba7b8dd34323399cee13ceb9ab5387992b2816df3f8492c968fc93cbfd2d55965ac5e0bfc3cb21265b653
+  metadata.gz: ce9f545a04e8bbe9e09e390f969a4023b585ef5d843a1312cc0fa98b1f09c50957aa503674ed75c52c8162a0250dbe0bc2ac55d5ab2f4b6b2d52e3c6f0e1b5e8
+  data.tar.gz: b4d65a623e3f0084602525c1d6fd549f7001802cfaeaefe708ace3fb249c66ba4de37911b4f51aa179b0e300acde588b6d68a797ed9c0b237ca96f4da7728108

data/documentation/deep learning/basic_infos.txt

@@ -12,6 +12,11 @@ Install rust & tauri
 curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
 brew install openssl
 cargo install tauri-cli --force
+cargo add midir # to add midi dependencies to atome
+
+# install elementary
+ npm install @nick-thompson/elementary
+
 
 Install Homebrew
 

data/lib/atome/genesis/atomes.rb

@@ -1,5 +1,13 @@
 # frozen_string_literal: true
 
+new({ atome: :editor, type: :hash })
+
+new({ sanitizer: :editor }) do |params|
+  params = {} unless params.instance_of? Hash
+  params[:data] = [] unless params[:data]
+  params
+end
+
 new({ atome: :color, type: :hash })
 
 new({ sanitizer: :color }) do |params|
@@ -105,6 +113,7 @@ new({ sanitizer: :text }) do |params|
   params = { data: params } unless params.instance_of? Hash
   params
 end
+
 # for later use ( physical is a css like style)
 new({ atome: :human }) do |params|
   Universe.add_user = params[:id]
@@ -114,6 +123,9 @@ new({ atome: :paint })
 new({ atome: :vector })
 new({ atome: :table })
 new({ atome: :atomized, type: :hash })
+new({ atome: :map, type: :hash })
+new({atome: :vr, type: :hash})
+
 
 
 

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

@@ -1,61 +1,79 @@
 # frozen_string_literal: true
 class Atome
-  def animation_callback(proc_sub_category, value=nil)
+  def animation_callback(proc_sub_category, value = nil)
     proc_found = @animate_code[proc_sub_category]
-    instance_exec(value,&proc_found) if proc_found.is_a?(Proc)
+    instance_exec(value, &proc_found) if proc_found.is_a?(Proc)
   end
 end
 
 new({ particle: :touch, category: :event, type: :hash, store: false })
+
 new({ sanitizer: :touch }) do |params, user_bloc|
-  # user_params=params.dup
   if params
-    # TODO: factorise code below
     @touch ||= {}
     @touch_code ||= {}
+
     option = true
-    params = if params.instance_of? Hash
-         user_bloc =params.delete(:code) if params[:code]
-         @touch_code[params.keys[0]] = user_bloc
-         option = params[params.keys[0]]
-         @touch={ code: user_bloc}
-         params.keys[0]
-             else
-               case params
-               when true
-                 @touch_code[:tap] = user_bloc
-                 :tap
-               when :touch
-                 @touch_code[:tap] = user_bloc
-                 :tap
-               when :down
-                 @touch_code[:down] = user_bloc
-                 :down
-               when :up
-                 @touch_code[:up] = user_bloc
-                 :up
-               when :long
-                 @touch_code[:long] = user_bloc
-                 :long
-               when :double
-                 @touch_code[:double] = user_bloc
-                 :double
-               when false
-                 @touch_code[:remove] = user_bloc
-                 :remove
-               else
-                 @touch_code[:tap] = user_bloc
-                 :tap
-               end
-             end
 
-    @touch[params] = option
-    params
+    key = if params.is_a?(Hash)
+
+            case
+            when params.keys.include?("tap")
+              touch_handle_non_hash_params(:tap, params[:code])
+            when params.keys.include?("down")
+              touch_handle_non_hash_params(:down, params[:code])
+            when params.keys.include?("up")
+              touch_handle_non_hash_params(:up, params[:code])
+            when params.keys.include?("long")
+              touch_handle_non_hash_params(:long, params[:code])
+            when params.keys.include?("double")
+              touch_handle_non_hash_params(:double, params[:code])
+            when params.keys.include?(false)
+              touch_handle_non_hash_params(false, params[:code])
+            when params.keys.include?(:remove)
+              touch_handle_non_hash_params(false, params[:remove])
+            else
+              touch_handle_non_hash_params(:touch, params[:code])
+            end
+
+          else
+            touch_handle_non_hash_params(params, user_bloc)
+          end
+
+    @touch[key] = option
+    key
   else
     @touch = false
     params
   end
 end
+
+def touch_handle_non_hash_params(params, user_bloc)
+  case params
+  when true, :touch, :tap
+    (@touch_code[:tap] ||= []) << user_bloc
+    :tap
+  when :down
+    (@touch_code[:down] ||= []) << user_bloc
+    :down
+  when :up
+    (@touch_code[:up] ||= []) << user_bloc
+    :up
+  when :long
+    (@touch_code[:hold] ||= []) << user_bloc
+    :long
+  when :double
+    (@touch_code[:doubletap] ||= []) << user_bloc
+    :double
+  when false
+    (@touch_code[:remove] ||= []) << user_bloc
+    :remove
+  else
+    (@touch_code[:tap] ||= []) << user_bloc
+    :tap
+  end
+end
+
 new({ particle: :play, category: :event, type: :boolean, store: false })
 new({ sanitizer: :play }) do |params, user_bloc|
   @play ||= {}
@@ -101,7 +119,7 @@ new({ sanitizer: :on }) do |params, user_bloc|
   params = if params.instance_of? Hash
              @on_code[:view_resize] = user_bloc
              option = params[params.keys[0]]
-             @resize={ code: user_bloc}
+             @resize = { code: user_bloc }
              :resize
            else
              case params
@@ -109,10 +127,10 @@ new({ sanitizer: :on }) do |params, user_bloc|
                @on_code[:view_resize] = user_bloc
                :resize
              when :remove
-
                :remove
              else
-               @on_code[:view_resize] = user_bloc
+               @on_code[:view_resize] ||= []
+               @on_code[:view_resize] << user_bloc
                option = params
                :resize
              end
@@ -126,50 +144,66 @@ new({ particle: :drag, category: :event, type: :boolean, store: false })
 new({ sanitizer: :drag }) do |params, user_bloc|
   @drag ||= {}
   @drag_code ||= {}
+
   option = true
   params = if params.instance_of? Hash
-       user_bloc =params.delete(:code) if params[:code]
-       @drag_code[params.keys[0]] = user_bloc
-       option = params[params.keys[0]]
-       @drag={ code: user_bloc}
-       params.keys[0]
+             user_bloc = params.delete(:code) if params[:code]
+             if user_bloc
+               @drag_code[params.keys[0]] = [user_bloc]
+             else
+               @drag_code[params.keys[0]] = []
+             end
+             option = params[params.keys[0]]
+             @drag = { code: [user_bloc] }
+             params.keys[0]
            else
              case params
              when true
-               @drag_code[:move] = user_bloc
+               @drag_code[:move] ||= []
+               @drag_code[:move] << user_bloc
                :move
              when :move
-               @drag_code[:move] = user_bloc
+               @drag_code[:move] ||= []
+               @drag_code[:move] << user_bloc
                :move
              when :drag
-               @drag_code[:move] = user_bloc
+               @drag_code[:move] ||= []
+               @drag_code[:move] << user_bloc
                :move
              when :clone
-               @drag_code[:clone] = user_bloc
+               @drag_code[:clone] ||= []
+               @drag_code[:clone] << user_bloc
                :clone
              when :start
-               @drag_code[:start] = user_bloc
+               @drag_code[:start] ||= []
+               @drag_code[:start] << user_bloc
                :start
              when :stop
-               @drag_code[:end] = user_bloc
+               @drag_code[:end] ||= []
+               @drag_code[:end] << user_bloc
                :end
              when :end
-               @drag_code[:end] = user_bloc
+               @drag_code[:end] ||= []
+               @drag_code[:end] << user_bloc
                :end
              when :locked
-               @drag_code[:locked] = user_bloc
+               @drag_code[:locked] ||= []
+               @drag_code[:locked] << user_bloc
                :locked
              when false
-               @drag_code[:remove] = user_bloc
+
+               @drag_code[:remove] ||= []
+               @drag_code[:remove] << option
                :remove
              else
-               @drag_code[:move] = user_bloc
-               :move
+               @drag_code[:move] ||= []
+               @drag_code[:move] << user_bloc
              end
 
            end
   @drag[params] = option
   if params == :remove
+    @drag_code[:remove] << option
     params = false
   else
     @drag[params] = option
@@ -183,30 +217,44 @@ new({ sanitizer: :drop }) do |params, user_bloc|
   @drop_code ||= {}
   option = true
   params = if params.instance_of? Hash
-       user_bloc =params.delete(:code) if params[:code]
-       @drop_code[params.keys[0]] = user_bloc
-       option = params[params.keys[0]]
-       @drop={ code: user_bloc}
-       params.keys[0]
+             user_bloc = params.delete(:code) if params[:code]
+             @drop_code[params.keys[0]] = [user_bloc]
+             option = params[params.keys[0]]
+             @drop = { code: [user_bloc] }
+             params.keys[0]
            else
              case params
              when true
-               @drop_code[:dropped] = user_bloc
+               @drop_code[:dropped] ||= []
+               @drop_code[:dropped] << user_bloc
                :dropped
              when :enter
-               @drop_code[:enter] = user_bloc
+               @drop_code[:enter] ||= []
+               @drop_code[:enter] << user_bloc
                :enter
              when :activate
-               @drop_code[:activate] = user_bloc
+               @drop_code[:activate] ||= []
+               @drop_code[:activate] << user_bloc
                :activate
              when :deactivate
-               @drop_code[:deactivate] = user_bloc
+               @drop_code[:deactivate] ||= []
+               @drop_code[:deactivate] << user_bloc
                :deactivate
+             when :remove
+               @drop_code[:remove] ||= []
+               @drop_code[:remove] << user_bloc
+               :remove
+             when false
+               @drop_code[:remove] ||= []
+               @drop_code[:remove] << user_bloc
+               :remove
              when :leave
-               @drop_code[:leave] = user_bloc
+               @drop_code[:leave] ||= []
+               @drop_code[:leave] << user_bloc
                :leave
              else
-               @drop_code[:dropped] = user_bloc
+               @drop_code[:dropped] ||= []
+               @drop_code[:dropped] << user_bloc
                :dropped
              end
 
@@ -222,35 +270,40 @@ new({ sanitizer: :over }) do |params, user_bloc|
   @over_code ||= {}
   option = true
   params = if params.instance_of? Hash
-       user_bloc =params.delete(:code) if params[:code]
-       @over_code[params.keys[0]] = user_bloc
-       option = params[params.keys[0]]
-       @over={ code: user_bloc}
+             user_bloc = params.delete(:code) if params[:code]
+             @over_code[params.keys[0]] = [user_bloc]
+             option = params[params.keys[0]]
+             @over = { code: [user_bloc] }
 
-       params.keys[0]
+             params.keys[0]
            else
              case params
              when true
-               @over_code[:over] = user_bloc
+               @over_code[:flyover] ||= []
+               @over_code[:flyover] << user_bloc
                :over
              when :over
-               @over_code[:over] = user_bloc
+               @over_code[:flyover] ||= []
+               @over_code[:flyover] << user_bloc
                :over
              when :enter
-               @over_code[:enter] = user_bloc
+               @over_code[:enter] ||= []
+               @over_code[:enter] << user_bloc
                :enter
              when :leave
-               @over_code[:leave] = user_bloc
+               @over_code[:leave] ||= []
+               @over_code[:leave] << user_bloc
                :leave
-               # when false
-               #   false
              else
+               @over_code[:flyover] ||= []
+               @over_code[:flyover] << user_bloc
                :over
              end
 
            end
 
   @over[params] = option
+
   params
 
 end
@@ -278,15 +331,8 @@ new({ sanitizer: :keyboard }) do |params, user_bloc|
 
   option = {}
   params = if params.instance_of? Hash
-             # @keyboard_code[:keyboard] = user_bloc
-             # option = params[params.keys[0]]
-             # :remove
-             user_bloc =params.delete(:code) if params[:code]
-             @keyboard_code[params.keys[0]] = user_bloc
              option = params[params.keys[0]]
              params.keys[0]
-             @keyboard={ code: user_bloc}
-
            else
              case params
              when true
@@ -312,7 +358,6 @@ new({ sanitizer: :keyboard }) do |params, user_bloc|
 
            end
   @keyboard[params] = option
-
   params
 end
 new({ particle: :resize, category: :event, type: :boolean, store: false })
@@ -324,8 +369,7 @@ new({ sanitizer: :resize }) do |params, user_bloc|
   params = if params.instance_of? Hash
              @resize_code[:resize] = user_bloc
              option = params[params.keys[0]]
-             @resize={ code: user_bloc}
-
+             @resize = { code: user_bloc }
              :resize
            else
              case params
@@ -351,16 +395,16 @@ new({ particle: :overflow, category: :event, type: :boolean }) do |params, bloc|
 
 end
 new({ particle: :animate, category: :event, type: :hash }) do |params, proc|
-  if params.instance_of? Hash
-    params = { from: 0, to: 300, duration: 1000 }.merge(params)
-  else
-    params = { from: 0, to: 300, duration: 1000 }
-  end
+  params = if params.instance_of? Hash
+             { from: 0, to: 300, duration: 1000 }.merge(params)
+           else
+             { from: 0, to: 300, duration: 1000 }
+           end
   # @animate_code["#{params[:particle]}"] = proc
   if params[:end]
     @animate_code["#{params[:end]}_end"] = proc
   else
-    @animate_code||= {}
+    @animate_code ||= {}
     @animate_code["#{params[:particle]}"] = proc
   end
 

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

@@ -61,4 +61,5 @@ end
 new({ particle: :format, category: :identity, type: :string })
 new({ particle: :alien, category: :identity, type: :string }) # special particel that old alien object
 
-new({ particle: :email, category: :identity, type: :string })
+new({ particle: :email, category: :identity, type: :string })
+

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

@@ -105,4 +105,29 @@ new ({ particle: :increment, category: :spatial, type: :hash }) do |params|
     prev_value = send(particle)
     send(particle, value + prev_value)
   end
+end
+
+new({particle: :longitude}) do |params, _user_proc|
+  render(:map, {longitude: params })
+  params
+end
+
+new({particle: :latitude}) do |params, _user_proc|
+  render(:map, {latitude: params })
+  params
+end
+
+new({particle: :location}) do |params, _user_proc|
+  render(:map, params)
+  params
+end
+
+new({particle: :zoom, specific: :map}) do |params, _user_proc|
+  render(:map_zoom, params)
+  params
+end
+
+new({particle: :pan, specific: :map}) do |params, _user_proc|
+  render(:map_pan, params)
+  params
 end

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

@@ -60,19 +60,29 @@ new({ particle: :delete, category: :utility, type: :boolean, render: false }) do
       grab(attach).unfasten([id])
       Universe.delete(@aid)
     end
+  elsif params == false
+
+
+    cells.delete(true)
+
+    # touch(false)
+    # render(:delete, params)
+    render(:delete, params)
+    Universe.delete(@aid)
   elsif params.instance_of? Hash
     # if we are on a matrix we delete cells found & group found
     cells.delete(true)
     group.delete(true)
     touch(false)
-    if params[:recursive]
+    if params[:recursive] == true
       grab(attach).unfasten([id])
       unless grab(@id).tag && (grab(@id).tag[:persistent] || grab(@id).tag[:system])
         fasten.each do |atttached_atomes|
           delete_recursive(atttached_atomes)
         end
         # touch(false)
-        render(:delete, params)
+        # render(:delete, params)
+        # html.delete(@id)
         Universe.delete(@aid)
       end
     elsif params[:force]
@@ -82,10 +92,7 @@ new({ particle: :delete, category: :utility, type: :boolean, render: false }) do
       end
       touch(false)
       render(:delete, params)
-      # alert "Universe : #{Universe.atomes[@aid]}"
-      # alert "length = #{Universe.atomes.length}"
       Universe.delete(@aid)
-      # alert "Universe : #{Universe.atomes.length}"
 
     else
       # the machine try to find the sub particle id and remove it eg a.delete(monitor: :my_monitor) remove the monitor
@@ -272,3 +279,4 @@ new({ particle: :storage, category: :utility, type: :hash })
 new({ particle: :state, category: :utility, type: :symbol })
 new({ particle: :record, category: :utility, type: :hash })
 new({ particle: :preview, category: :utility, type: :hash })
+new({particle: :meteo})

data/lib/atome/utilities/essentials.rb

@@ -16,10 +16,10 @@ module Essentials
   @default_params = {
     # Warning :  type must be define first
     render_engines: [:html],
-    image: { type: :image, left: 0, top: 0},
+    # image: { type: :image, left: 0, top: 0},
     table: { type: :table, left: 0, top: 0, option: {}},
     # FIXME : look at build_atome FIXME to resolve default parent attachment problem
-    video: { type: :video },
+    # video: { type: :video },
     animation: { type: :animation, attach: :black_matter },
     element: { type: :element, renderers: [], attach: :black_matter },
     box: { type: :shape, width: 39, height: 39,
@@ -36,6 +36,9 @@ module Essentials
     shape: { type: :shape, width: 39, height: 39,
              apply: [:shape_color],
              left: 0, top: 0 },
+    vr: { type: :vr, width: 390, height: 390,
+             apply: [:shape_color],
+             left: 0, top: 0 },
     text: { type: :text, component: { size: 12 },left: 0, top: 0,
             apply: [:text_color],
             width: :auto, height: :auto,

data/lib/atome/version.rb

@@ -3,5 +3,5 @@
 #  return atome version
 
 class Atome
-  VERSION = '0.5.7.5.4'
+  VERSION = '0.5.7.5.9'
 end

data/lib/molecules/intuition/tools.rb

@@ -63,7 +63,7 @@ class Atome
               atome_found = grab(id_found)
 
               is_descendant_of_intuition = atome_found.descendant_of?(:intuition).to_s if atome_found
-              # # the condition below is use to exclude the treatment any object in the intuition layer
+              # the condition below is use to exclude the treatment any object in the intuition layer
               unless is_descendant_of_intuition == 'true'
 
                 Universe.active_tools.each do |tool|

data/lib/molecules/intuition/utilities.rb

@@ -736,3 +736,6 @@ new(molecule: :buttons) do |params, &bloc|
   main
 end
 
+new(molecule: :editor) do |params, &bloc|
+
+end

data/lib/platform_specific/opal/extensions/object.rb

@@ -2,5 +2,7 @@
 
 # main add on
 def alert(val)
-  JS.eval("alert('#{val.to_s}')")
+  val = val.to_s
+  escaped_val = val.gsub("'", "\\\\'")
+  JS.eval("alert('#{escaped_val}')")
 end

data/lib/platform_specific/wasm/atome_wasm_extensions.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 def alert(val)
-  escaped_val = val.to_s.gsub("'", "\\'").gsub("\n", "\\n")
+  val = val.to_s
+  escaped_val = val.gsub("'", "\\\\'").gsub("\n", "\\n")
   JS.eval("alert('#{escaped_val}')")
 end
 

data/lib/renderers/html/event.rb

@@ -11,8 +11,13 @@ new({ method: :drag, type: :symbol, renderer: :html }) do |params|
 end
 
 new({ method: :drop, type: :symbol, renderer: :html }) do |params|
-  option = @drop[params]
-  html.event(:drop, params, option)
+  if params
+    option = @drop[params]
+    html.event(:drop, params, option)
+  else
+    html.event(:drop, remove, true)
+  end
+
 end
 
 new({ method: :touch, type: :integer, renderer: :html }) do |params|
@@ -25,13 +30,21 @@ new({ method: :touch, type: :integer, renderer: :html }) do |params|
 end
 
 new({ method: :over, type: :integer, renderer: :html }) do |params|
-  option = @over[params]
-  html.event(:over, params, option)
+  if params
+    option = @over[params]
+    html.event(:over, params, option)
+  else
+    html.event(:over, :remove, true)
+  end
 end
 
 new({ method: :keyboard, renderer: :html }) do |params|
-  option = @keyboard[params]
-  html.event(:keyboard, params, option)
+  if params
+    option = @keyboard[params]
+    html.event(:keyboard, params, option)
+  else
+    html.event(:keyboard, :remove, true)
+  end
 end
 
 new({ method: :play, renderer: :html }) do |params = true|
@@ -43,6 +56,7 @@ end
 
 new({ method: :on, renderer: :html }) do |params|
   option = @on[params]
+
   html.on(params, option)
 end