atome 0.5.7.3.0 → 0.5.7.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63cd85893b4535b12f8f24da43d2d615234820584a74ae4e4f67c2c1da28068d
-  data.tar.gz: 8c0e70603aee556e09abb0867d0084ccea315d54334ddc6328bf54e8da254a59
+  metadata.gz: 6bf0aa348d59571692a14c0bbd2910cddcb94fa1c1507e5a2d9ccdbd9c75f565
+  data.tar.gz: 43f0dd9848d94f025018efd4b86fc6d3209998fe37e23f34c707a97a0f7680ca
 SHA512:
-  metadata.gz: 4f6d187398d27418a21ad283dc4184b0c047635665133fbd05790d49c2592d9213898a6396dfe943a38b68ccda327d205e08d168ef92d7212243a7e1e4b003a2
-  data.tar.gz: 686e3049efeef466841eb3979202d4be3ac753123e419d71a8fb3565159aad2e58ce66e9e28a1de6328243aed298a7480c0ce3504cbc1d00aa3ba80238a0ca5d
+  metadata.gz: 83d133860dd02158c3f8b72923987299a90b1f84c90816c9a79c67be923c4d56815fd76433117540ce9eb2341ad2f51cbdc2d32ee0b28e623dfb3de709cac572
+  data.tar.gz: 18580c37a8635cd805e23fa9daf8d39b7f7ccca3d6a954d731ca0b9bf819b5a1dffda460f25b27217b5a51e112409db90f3d897a91b6465f59220486a01f8f97

data/lib/atome/atome.rb

@@ -48,6 +48,7 @@ class Atome
     @collect = {}
     @int8 = {}
     @css = {}
+    @code={}
     @aid=  new_atome[:aid]  || identity_generator
     @controller_proc=[]
     @id = new_atome[:id] || @aid

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

@@ -4,14 +4,14 @@ new({ particle: :touch, category: :event, type: :hash, store: false })
 new({ sanitizer: :touch }) do |params, user_bloc|
   if params
     # TODO: factorise code below
-    # alert  "touch_code: #{@touch_code}"
     @touch ||= {}
     @touch_code ||= {}
     option = true
     params = if params.instance_of? Hash
-               @touch_code[params.keys[0]] = user_bloc
-               option = params[params.keys[0]]
-               params.keys[0]
+         user_bloc =params.delete(:code) if params[:code]
+         @touch_code[params.keys[0]] = user_bloc
+         option = params[params.keys[0]]
+         params.keys[0]
              else
                case params
                when true
@@ -32,8 +32,6 @@ new({ sanitizer: :touch }) do |params, user_bloc|
                when :double
                  @touch_code[:double] = user_bloc
                  :double
-                 # when :remove
-                 #   params
                when false
                  @touch_code[:remove] = user_bloc
                  :remove
@@ -122,9 +120,10 @@ new({ sanitizer: :drag }) do |params, user_bloc|
   @drag_code ||= {}
   option = true
   params = if params.instance_of? Hash
-             @drag_code[params.keys[0]] = user_bloc
-             option = params[params.keys[0]]
-             params.keys[0]
+       user_bloc =params.delete(:code) if params[:code]
+       @drag_code[params.keys[0]] = user_bloc
+       option = params[params.keys[0]]
+       params.keys[0]
            else
              case params
              when true
@@ -175,9 +174,10 @@ new({ sanitizer: :drop }) do |params, user_bloc|
   @drop_code ||= {}
   option = true
   params = if params.instance_of? Hash
-             @drop_code[params.keys[0]] = user_bloc
-             option = params[params.keys[0]]
-             params.keys[0]
+       user_bloc =params.delete(:code) if params[:code]
+       @drop_code[params.keys[0]] = user_bloc
+       option = params[params.keys[0]]
+       params.keys[0]
            else
              case params
              when true
@@ -212,10 +212,10 @@ new({ sanitizer: :over }) do |params, user_bloc|
   @over_code ||= {}
   option = true
   params = if params.instance_of? Hash
-
-             @over_code[params.keys[0]] = user_bloc
-             option = params[params.keys[0]]
-             params.keys[0]
+       user_bloc =params.delete(:code) if params[:code]
+       @over_code[params.keys[0]] = user_bloc
+       option = params[params.keys[0]]
+       params.keys[0]
            else
              case params
              when true
@@ -271,8 +271,12 @@ 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]]
-             :remove
+             params.keys[0]
            else
              case params
              when true

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

@@ -71,6 +71,10 @@ new({ post: :remove }) do |params|
       end
 
     end
+  else
+    # the systems send an id we have to remove it from parent too
+    grab(params).attached.delete(id)
+    grab(params).affect.delete(id)
   end
   params
 end

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

@@ -1,11 +1,33 @@
 # frozen_string_literal: true
 
 new({ particle: :renderers, category: :utility, type: :string })
-new({ particle: :code, category: :utility, type: :string })
-new({ particle: :run, category: :utility, type: :boolean }) do |params|
-  code_found = @code
-  instance_exec(params, &code_found) if code_found.is_a?(Proc)
+new({ particle: :code, category: :utility, type: :string, store: false }) do |params, code|
+  @code[params]=code
 end
+# new({ particle: :run, category: :utility, type: :boolean }) do |params|
+#   code_found = @code
+#   instance_exec(params, &code_found) if code_found.is_a?(Proc)
+# end
+
+new({ particle: :run }) do |params, code|
+    instance_exec(&params) if params.is_a?(Proc)
+    code_found = @code[params]
+    instance_exec(params, &code_found) if code_found.is_a?(Proc)
+end
+
+new({ particle: :target }) do |params|
+  params.each do |atome_f, value_f|
+    if value_f.instance_of?(Hash)
+      value_f.each do |part_f, part_val|
+        grab(atome_f).send(part_f, part_val)
+      end
+    else
+      grab(atome_f).send(value_f)
+    end
+  end
+end
+
+
 # new({ particle: :broadcast })
 
 def delete_recursive(atome_id, force=false)

data/lib/atome/version.rb

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

data/lib/molecules/intuition/tools.rb

@@ -1,7 +1,13 @@
 # frozen_string_literal: true
 
+def truncate_string(string, max_length)
+  string.length > max_length ? string.slice(0, max_length) + "." : string
+end
+
 size = 33
 smooth = 3
+margin = 3
+text_color = { alpha: 0.3, red: 1, green: 1, blue: 1 }
 shadow({
          id: :tool_shade,
          left: 3, top: 3, blur: 3,
@@ -15,10 +21,13 @@ border({ id: :tool_box_border, thickness: 1, red: 1, green: 1, blue: 1, alpha: 0
 element({ aid: :toolbox_style, id: :toolbox_style, data: {
   color: :gray,
   size: size,
-  smooth: smooth
+  margin: margin,
+  smooth: smooth,
+  text_color: text_color,
 } })
 
 class Atome
+
   def toolbox(tool_list)
     @toolbox = tool_list[:tools]
     tool_list[:tools].each_with_index do |root_tool, index|
@@ -53,12 +62,16 @@ class Atome
             y = event[:clientY]
             elements = JS.global[:document].elementsFromPoint(x, y)
             elements.to_a.each do |atome_touched|
-              id_found = atome_touched[:id].to_s
-              atome_found = grab(id_found)
-              unless atome_found && atome_found.tag[:system]
-                Universe.active_tools.each do |tool|
-                  apply_tool(tool, atome_found, event)
+              unless atome_touched.to_s == 'html'
+                id_found = atome_touched[:id].to_s
+                atome_found = grab(id_found)
+                # unless (atome_found && atome_found.tag[:system])
+                if atome_found && !atome_found.tag[:system]
+                  Universe.active_tools.each do |tool|
+                    apply_tool(tool, atome_found, event)
+                  end
                 end
+
                 break
               end
             end
@@ -150,10 +163,20 @@ class Atome
         tool_actions[:action] = { noop: true }
         current_tool.data = tool_actions
       end
-      # tool_actions.delete(:inactivation)
-      # alert "==> #{tool_actions[:inactivation]}"
-      # puts "==> #{method_found},\n==>  #{current_tool.id} ,\nactions ==>  #{tool_actions},\n==>  #{atome_touched},\n==> #{a_event}"
-      send(method_found, current_tool, tool_actions, atome_touched, a_event)
+      tool_name = tool.to_s.sub('_tool', '')
+      tools_scheme = Universe.tools[tool_name.to_sym]
+      puts "1 - here slider treat either the target atome types or current atome"
+      puts "2 - need to created a list instead of choosing the last atome found of it's kind"
+
+      target = if tools_scheme[:target]
+                 grab(atome_touched.send(tools_scheme[:target]).last)
+               else
+                 atome_touched
+               end
+      tools_scheme[:particles]&.each do |particle_f, value_f|
+        target.send(particle_f, value_f)
+      end
+      send(method_found, current_tool, tool_actions, target, a_event)
     end
 
   end
@@ -178,9 +201,8 @@ class Atome
     alterations = tool_scheme[:alteration] ? tool_scheme[:alteration].keys : []
     creations = tool_scheme[:creation] ? tool_scheme[:creation].keys : []
     prev_auth = Universe.allow_localstorage ||= []
-    events_allow = [:top, :left, :right, :bottom, :width, :height]
+    events_allow = %i[top left right bottom width height]
     storage_allowed = events_allow.concat(alterations).concat(creations).concat(prev_auth).uniq
-    # alert "#{events_allow}, \n#{alterations} , \n#{creations}, \n #{prev_auth}, \n\n\n#{storage_allowed}"
 
     Universe.allow_localstorage = storage_allowed
     # we set edit mode to true (this allow to prevent user atome to respond from click)
@@ -191,7 +213,9 @@ class Atome
     tool.data[:created] = []
     tool.data[:prev_states] = {}
     # generic behavior
-    tool.apply(:active_tool_col)
+    # tool.apply(:active_tool_col)
+    grab("#{tool_name}_icon").color(:white)
+    grab("#{tool_name}_label").color(:white)
     Universe.active_tools << tool_name
     # activation code
     activation_code = tool_scheme[:activation]
@@ -237,7 +261,8 @@ class Atome
       # we delete the attached toolbox if it exist
       toolbox_tool.delete({ force: true })
     end
-
+    grab("#{tool_name}_icon").color(grab(:toolbox_style).data[:text_color])
+    grab("#{tool_name}_label").color(grab(:toolbox_style).data[:text_color])
     # when closing delete tools action from tool_actions_to_exec
     Universe.active_tools.delete(tool_name)
     # we check if all tools are inactive if so we set edit_mode to false
@@ -273,7 +298,9 @@ class Atome
     grab(:intuition).storage[:tool_open] ||= []
     grab(:intuition).storage[:tool_open] << tool_name
     size = grab(:toolbox_style).data[:size]
+    margin = grab(:toolbox_style).data[:margin]
     smooth = grab(:toolbox_style).data[:smooth]
+    text_color = grab(:toolbox_style).data[:text_color]
     case orientation_wanted
     when :sn
       top = :auto
@@ -304,12 +331,13 @@ class Atome
                                   # orientation: orientation_wanted,
                                   top: top,
                                   bottom: bottom,
+                                  depth: 0,
                                   left: left,
                                   right: right,
                                   width: size,
                                   height: size,
                                   smooth: smooth,
-                                  apply: [:inactive_tool_col, :tool_box_border, :tool_shade],
+                                  apply: %i[inactive_tool_col tool_box_border tool_shade],
                                   state: :closed,
                                   data: { method: method,
                                           action: action,
@@ -328,24 +356,149 @@ class Atome
     icon = tool.vector({ tag: { system: true }, left: 9, top: :auto, bottom: 9, width: 18, height: 18, id: "#{tool_name}_icon",
                          data: { path: { d: edition, id: "p1_#{tool_name}_icon", stroke: :black, 'stroke-width' => 37, fill: :white } } })
 
-    icon.color(:yellowgreen)
+    icon.color(text_color)
+
+    tool.text({ tag: { system: true }, data: truncate_string(label, 5), component: { size: 9 }, center: { x: 0 }, top: :auto, bottom: 0,
+                color: text_color, id: "#{tool_name}_label", width: size, position: :absolute })
 
-    tool.text({ tag: { system: true }, data: label, component: { size: 9 }, color: :grey, id: "#{tool_name}_label" })
     code_for_zone = tool_scheme[:zone]
     tool.instance_exec(tool, &code_for_zone) if code_for_zone.is_a? Proc
     tool.active(false)
-    tool.touch(true) do
-      # we add all specific tool actions to @tools_actions_to_exec hash
-      # we set allow_tool_operations to false to ignore tool operation when clicking on a tool
-      Universe.allow_tool_operations = false
-      # we create the creation_layer if not already exist
-      if tool.active == false # first click
-        tool.activate_tool
+    tool.touch(:long) do
+      tool.instance_variable_set('@prevent_action', true)
+      if tool.instance_variable_get('@tool_open') == true
+        tool.instance_variable_set('@tool_open', false)
+        tool_scheme[:particles].each do |particle, value|
+          grab("tool_particle_#{particle}").delete({ force: true })
+        end
+        tool.width(size)
       else
-        tool.deactivate_tool
-        tick[tool_name] = 0
+        tool.instance_variable_set('@tool_open', true)
+
+        tool_scheme[:particles].each_with_index do |(particle_name, _value_), ind|
+
+          particle = tool.box({ id: "tool_particle_#{particle_name}", tag: { system: true }, depth: 1, smooth: smooth,
+                                apply: %i[inactive_tool_col tool_box_border tool_shade],
+                                width: size, height: size, left: ind * (size + margin) + size })
+          particle_label = particle.text({
+                                           id: "tool_particle_name_#{particle_name}",
+                                           tag: { system: true },
+                                           data: truncate_string(particle_name, 5),
+                                           center: { x: 0 },
+                                           position: :absolute,
+                                           component: { size: 9 },
+                                           color: text_color,
+                                           top: :auto,
+                                         }
+
+          )
+          label_value = particle.text({
+                                        id: "tool_particle_value_#{particle_name}",
+                                        data: 0.00,
+                                        tag: { system: true },
+                                        center: { x: 0 },
+                                        position: :absolute,
+                                        component: { size: 9 },
+                                        color: text_color,
+                                        top: margin,
+
+                                      })
+          particle_label.center({ x: 0 })
+          particle_label.top(:auto)
+          particle_label.bottom(0)
+          particle.touch(true) do
+            puts "1 ======> opening !!!#{particle_name}"
+            tool.instance_variable_set('@prevent_action', true)
+            slider_id = "particle_slider_#{particle_name}"
+            if particle.instance_variable_get('@active')
+              grab(slider_id).delete({ force: true })
+              particle.instance_variable_set('@active', false)
+              # particle.top(:auto)
+              # particle.top(:bottom)
+              particle.height(size)
+              particle.top(0)
+            else
+              particle.height(139 + size / 2)
+              particle.top(-139 + size)
+              # particle.top(:auto)
+              # particle.top(:bottom)
+              # particle.color(:green)
+              slider_id = "particle_slider_#{particle_name}"
+              slider_f = particle.slider({ orientation: :vertical,
+                                           id: slider_id,
+                                           range: { color: { alpha: 0 } },
+                                           value: 55,
+                                           depth: 2,
+                                           center: { x: 0 },
+                                           width: 18, height: 123, smooth: 1,
+                                           left: 0,
+                                           top: size / 2,
+                                           color: { alpha: 0 },
+                                           cursor:
+                                             { color: { alpha: 1, red: 0.9, green: 0.9, blue: 0.0 },
+                                               width: 18, height: 12, smooth: 3 } }) do |value|
+                # Slider actions below:
+                if grab(slider_id).instance_variable_get('@initialised')
+                  Atome.selection.each do |atome_id_to_treat|
+
+                    # puts "-------> #{tool_scheme[:particles][particle_name]} , #{value }"
+                    tool_scheme[:particles][particle_name] = value.to_f / 100
+                    # tools_scheme[:particles]
+                    atome_found = grab(atome_id_to_treat)
+                    target = grab(atome_found.color.last)
+
+                    target.send(particle_name, value.to_f / 100)
+                    label_value.data(value.to_f / 100)
+                    # puts "+++++++> #{tool_scheme[:particles]} }"
+                  end
+                end
+              end
+              puts "2  ======> opening !!!#{particle_name}"
+
+              Atome.selection.each do |atome_id_to_treat|
+                atome_found = grab(atome_id_to_treat)
+                puts "here slider treat either the target atome types or current atome"
+                puts "need to created a list instead of choosing the last atome found of it's kind"
+                target = if tool_scheme[:target]
+                           grab(atome_found.send(tool_scheme[:target]).last)
+                         else
+                           atome_found
+                         end
+                value_found = target.send(particle_name)
+                slider_f.value(value_found * 100)
+              end
+              slider_f.instance_variable_set('@initialised', true)
+              particle.instance_variable_set('@active', true)
+            end
+
+          end
+        end if tool_scheme[:particles]
+        # tool.width(((size + margin) * (tool_scheme[:particles].length + 1)))
       end
+
+    end
+    tool.touch(:down) do
+      tool.depth(999)
     end
+    tool.touch(true) do
+
+      # puts "==> prevent : #{tool.instance_variable_get('@prevent_action')}"
+      unless tool.instance_variable_get('@prevent_action')
+        # we add all specific tool actions to @tools_actions_to_exec hash
+        # we set allow_tool_operations to false to ignore tool operation when clicking on a tool
+        Universe.allow_tool_operations = false
+        # we create the creation_layer if not already exist
+        if tool.active == false # first click
+          tool.activate_tool
+        else
+          tool.deactivate_tool
+          tick[tool_name] = 0
+        end
+      end
+      puts 'reactivation'
+      tool.instance_variable_set('@prevent_action', false)
+    end
+
   end
 
 end

data/lib/molecules/intuition/utilities.rb

@@ -154,12 +154,13 @@ new({ molecule: :slider }) do |params, bloc|
   new_id = params.delete(:id) || identity_generator
 
   default_smooth = 9
-  default_slider_particles = { id: new_id, 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%' }
+  default_slider_particles = { id: new_id, color: color_found, width: 333, height: 33, left: 0, top: 0,
+                               smooth: default_smooth, tag: { system: true } }
+  default_cursor_particles = { color: color_found, width: 29, height: 29, left: 0, smooth: '100%', tag: { system: true } }
   cursor_found = params.delete(:cursor)
   slider_particle = default_slider_particles.merge(params)
   slider = box(slider_particle)
-
+  slider.remove(:box_color)
   slider_shadow = slider.shadow({
                                   id: :s2,
                                   left: 3, top: 3, blur: 9,
@@ -167,8 +168,8 @@ new({ molecule: :slider }) do |params, bloc|
                                   red: 0, green: 0, blue: 0, alpha: 0.7
                                 })
 
-  range = slider.box({ id: "#{slider.id}_range", top: :auto, bottom: 0 })
-
+  range = slider.box({ id: "#{slider.id}_range", top: :auto, bottom: 0,tag: { system: true } })
+  range.remove(:box_color)
   if range_found
     range.apply(slider_shadow.id,)
     range_found.each do |part, val|
@@ -179,6 +180,7 @@ new({ molecule: :slider }) do |params, bloc|
   end
   cursor_particle = default_cursor_particles.merge(cursor_found).merge({ id: "#{slider.id}_cursor" })
   cursor = slider.box(cursor_particle)
+  cursor.remove(:box_color)
   cursor_left = (slider_particle[:width] - cursor_particle[:width]) / 2.0
   cursor_top = (slider_particle[:height] - cursor_particle[:height]) / 2.0
 
@@ -305,9 +307,9 @@ new(molecule: :button) do |params, bloc|
   button = box(
     { renderers: renderer_found, id: new_id, type: :shape, color: back_col,
       left: 0, top: 0, data: '', attach: attach_to,
-      smooth: 3, overflow: :hidden,
+      smooth: 3, overflow: :hidden,tag: { system: true }
     })
-
+  button.remove(:box_color)
   button.touch(:down) do
     button.tick(:button)
     bloc.call((button.tick[:button] - 1) % states)
@@ -362,7 +364,7 @@ class Atome
 end
 
 new(molecule: :matrix) do |params, &bloc|
-  params  ||= {}
+  params ||= {}
   # We test if self is main if so we attach the matrix to the view
   parent_found = if self == self
                    grab(:view)
@@ -391,7 +393,7 @@ new(molecule: :matrix) do |params, &bloc|
   view_width = parent_found.to_px(:width)
   view_height = parent_found.to_px(:height)
   matrix_back = box({ id: "#{id}_background", width: size, height: size, color: { alpha: 0 } })
-
+  matrix_back.remove(:box_color)
   if view_width > view_height
     full_size = view_height * size_coefficient
     available_width = full_size - total_spacing_x
@@ -425,14 +427,17 @@ new(molecule: :matrix) do |params, &bloc|
   matrix_back.data(params)
   matrix_back
 end
+
 new(molecule: :page) do |params, &bloc|
   b = box({ color: :red, left: 99, drag: true })
+  b.remove(:box_color)
   b.text(params)
 end
+
 new(molecule: :application) do |params, &bloc|
 
   main_page = box({ drag: true, width: :auto, height: :auto, top: 0, bottom: 0, left: 0, right: 0 })
-
+  main_page.remove(:box_color)
   main_page
 
   # def new(params, &bloc)