atome 0.5.7.3.0 → 0.5.7.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63cd85893b4535b12f8f24da43d2d615234820584a74ae4e4f67c2c1da28068d
-  data.tar.gz: 8c0e70603aee556e09abb0867d0084ccea315d54334ddc6328bf54e8da254a59
+  metadata.gz: bda2b32c6739ba09c874bfdda703d1e64a3e01856b3f80fa01aba15866628335
+  data.tar.gz: 8ce5a6571be7d57c82aa64a345997f881a35c80ad12a3ec77b9ecc6a6fe00d47
 SHA512:
-  metadata.gz: 4f6d187398d27418a21ad283dc4184b0c047635665133fbd05790d49c2592d9213898a6396dfe943a38b68ccda327d205e08d168ef92d7212243a7e1e4b003a2
-  data.tar.gz: 686e3049efeef466841eb3979202d4be3ac753123e419d71a8fb3565159aad2e58ce66e9e28a1de6328243aed298a7480c0ce3504cbc1d00aa3ba80238a0ca5d
+  metadata.gz: 1e5d67579d27b6fe58b41e63a1b6ac4811b3d47e5cae67f005c234d835760721ddf6d5591594a011b660a719b4a0873b3f5c8eb7840e7a4886dd6cbcc31f2e5b
+  data.tar.gz: 4f01d01a81f832cd14741c3a97ba93b82ee717821971b42aaf9d72f6820975c8b46a0adea51cf679cf114dd80678cd55ef4371b18a4b23fcb18a9e0f48dc0849

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

@@ -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

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/version.rb

@@ -2,5 +2,5 @@
 
 #  return atome version
 class Atome
-  VERSION = '0.5.7.3.0'
+  VERSION = '0.5.7.3.1'
 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
@@ -427,12 +429,13 @@ new(molecule: :matrix) do |params, &bloc|
 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)

data/lib/renderers/html/html.rb

@@ -1139,70 +1139,78 @@ class HTML
 
   def touch_down(_option)
     @element[:style][:cursor] = 'pointer'
-
     @touch_down = @original_atome.instance_variable_get('@touch_code')[:down]
     interact = JS.eval("return interact('##{@id}')")
-    unless @touch_removed[:down]
-      interact.on('down') do |native_event|
-        event = Native(native_event)
-        # we use .call instead of instance_eval because instance_eval bring the current object as context
-        # and it's lead to a problem of context and force the use of grab(:view) when suing atome method such as shape ,
-        # group etc..
-        # @touch_down.call(event) if @touch_down.is_a?(Proc)  && (!Universe.edit_mode || @original_atome.tag[:system])
-        @touch_down.call(event) if event_validation(@touch_down)
-        # end
-      end
+    # unless @touch_removed[:down]
+    interact.on('down') do |native_event|
+      event = Native(native_event)
+      # we use .call instead of instance_eval because instance_eval bring the current object as context
+      # and it's lead to a problem of context and force the use of grab(:view) when suing atome method such as shape ,
+      # group etc..
+      # @touch_down.call(event) if @touch_down.is_a?(Proc)  && (!Universe.edit_mode || @original_atome.tag[:system])
+      @touch_down.call(event) if event_validation(@touch_down)
+      # end
+      # end
     end
   end
 
   def touch_tap(_option)
     @element[:style][:cursor] = 'pointer'
     interact = JS.eval("return interact('##{@id}')")
-    touch_tap = @original_atome.instance_variable_get('@touch_code')[:tap]
+    @touch_tap = @original_atome.instance_variable_get('@touch_code')[:tap]
     # unless @touch_removed[:tap]
     interact.on('tap') do |native_event|
+
       event = Native(native_event)
       # we use .call instead of instance_eval because instance_eval bring the current object as context
-      # and it's lead to a problem of context and force the use of grab(:view) when using atome method such as shape ,
+      # and it's lead to a problem of context and force the use of grab(:view) when suing atome method such as shape ,
       # group etc..
-      # @touch_tap.call(event) if @touch_tap.is_a?(Proc) && !Universe.edit_mode || !@original_atome.tag[:system]
-      touch_tap.call(event) if event_validation(touch_tap)
+      # @touch_up.call(event) if @touch_up.is_a?(Proc) && (!Universe.edit_mode || @original_atome.tag[:system])
+      # event = Native(native_event)
+      # ########## old code :
+      @touch_tap.call(event) if event_validation(@touch_tap)
+      # ########## new code:
+      # proc_content = @touch_tap.call(event) if event_validation(@touch_tap)
+      # if proc_content.instance_of? Hash
+      #   proc_content.each do |k, v|
+      #     @original_atome.send(k, v)
+      #   end
+      # end
     end
     # end
-
   end
 
   def touch_up(_option)
     @element[:style][:cursor] = 'pointer'
     interact = JS.eval("return interact('##{@id}')")
     @touch_up = @original_atome.instance_variable_get('@touch_code')[:up]
-    unless @touch_removed[:up]
-      interact.on('up') do |native_event|
-        event = Native(native_event)
-        # we use .call instead of instance_eval because instance_eval bring the current object as context
-        # and it's lead to a problem of context and force the use of grab(:view) when suing atome method such as shape ,
-        # group etc..
-        # @touch_up.call(event) if @touch_up.is_a?(Proc) && (!Universe.edit_mode || @original_atome.tag[:system])
-        @touch_up.call(event) if event_validation(@touch_up)
-      end
-
+    # unless @touch_removed[:up]
+    interact.on('up') do |native_event|
+      event = Native(native_event)
+      # we use .call instead of instance_eval because instance_eval bring the current object as context
+      # and it's lead to a problem of context and force the use of grab(:view) when suing atome method such as shape ,
+      # group etc..
+      # @touch_up.call(event) if @touch_up.is_a?(Proc) && (!Universe.edit_mode || @original_atome.tag[:system])
+      @touch_up.call(event) if event_validation(@touch_up)
     end
+
+    # end
   end
 
   def touch_double(_option)
     @element[:style][:cursor] = 'pointer'
     interact = JS.eval("return interact('##{@id}')")
     @touch_double = @original_atome.instance_variable_get('@touch_code')[:double]
-    unless @touch_removed[:double]
-      interact.on('doubletap') do |native_event|
-        event = Native(native_event)
-        # we use .call instead of instance_eval because instance_eval bring the current object as context
-        # and it's lead to a problem of context and force the use of grab(:view) when suing atome method such as shape ,
-        # group etc..
-        # @touch_double.call(event) if @touch_double.is_a?(Proc) && (!Universe.edit_mode || @original_atome.tag[:system])
-        @touch_double.call(event) if event_validation(@touch_double)
+    # unless @touch_removed[:double]
+    interact.on('doubletap') do |native_event|
+      event = Native(native_event)
+      # we use .call instead of instance_eval because instance_eval bring the current object as context
+      # and it's lead to a problem of context and force the use of grab(:view) when suing atome method such as shape ,
+      # group etc..
+      # @touch_double.call(event) if @touch_double.is_a?(Proc) && (!Universe.edit_mode || @original_atome.tag[:system])
+      @touch_double.call(event) if event_validation(@touch_double)
 
-      end
+      # end
     end
 
   end
@@ -1211,18 +1219,18 @@ class HTML
     @element[:style][:cursor] = 'pointer'
     @touch_long = @original_atome.instance_variable_get('@touch_code')[:long]
     interact = JS.eval("return interact('##{@id}')")
-    unless @touch_removed[:long]
-      interact.on('hold') do |native_event|
-        event = Native(native_event)
-        # we use .call instead of instance_eval because instance_eval bring the current object as context
-        # and it's lead to a problem of context and force the use of grab(:view) when suing atome method such as shape ,
-        # group etc..
-        @touch_long.call(event) if event_validation(@touch_long)
-        # @touch_long.call(event) if @touch_long.is_a?(Proc) && (!Universe.edit_mode || @original_atome.tag[:system])
-        # @touch_double.call(event) if event_validation(@touch_double)
+    # unless @touch_removed[:long]
+    interact.on('hold') do |native_event|
+      event = Native(native_event)
+      # we use .call instead of instance_eval because instance_eval bring the current object as context
+      # and it's lead to a problem of context and force the use of grab(:view) when suing atome method such as shape ,
+      # group etc..
+      @touch_long.call(event) if event_validation(@touch_long)
+      # @touch_long.call(event) if @touch_long.is_a?(Proc) && (!Universe.edit_mode || @original_atome.tag[:system])
+      # @touch_double.call(event) if event_validation(@touch_double)
 
-      end
     end
+    # end
   end
 
   def touch_remove(option)
@@ -1240,6 +1248,13 @@ class HTML
     when :tap
       @touch_removed[:tap] = true
       @touch_tap = ''
+      @touch_removed[:touch] = true
+      @touch_touch = ''
+    when :touch
+      @touch_removed[:tap] = true
+      @touch_tap = ''
+      @touch_removed[:touch] = true
+      @touch_touch = ''
     when :up
       @touch_removed[:up] = true
       @touch_up = ''

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

@@ -4,6 +4,7 @@ b = box()
 b.text('click me')
 orange=''
 b.touch(true) do
+
   c = grab(:view).circle({id: :circling, left: 222, color: :orange, blur: 1.9 })
   orange=c.box({id: :boxing,color: {id: :orange_col, red: 1, blue: 0.2 }, width: 33, height: 33, left: 123})
   orange.shadow({
@@ -23,10 +24,14 @@ b.touch(true) do
     end
   end
 
-  c.touch(true) do
-    c.delete({ recursive: true })
+  c.touch(:down) do
+    puts '1?'
+    grab(:circling).delete({ recursive: true }) if grab(:circling)
   end
   # alert orange.apply
+  wait 4 do
+    grab(:circling).delete({ recursive: true })if grab(:circling)
+  end
 end
 
 

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

@@ -1,4 +1,5 @@
 #  frozen_string_literal: true
+
 a=box({width: 666, height: 777, color: :orange})
 b = box({ left: 666, color: :blue, smooth: 6, id: :the_box2, depth: 1 , top: 66})
 cc=circle({color: :red, left: 0, top: 0})
@@ -16,8 +17,6 @@ b.drag(:stop) do
   clone.delete(true)
 end
 
-
-
 b.drag(:locked) do |event|
   dx = event[:dx]
   dy = event[:dy]
@@ -29,7 +28,6 @@ b.drag(:locked) do |event|
   puts "y: #{y}"
 end
 cc.drag({ restrict: {max:{ left: 240, top: 190}} }) do |event|
-
 end