atome 0.5.7.3.5 → 0.5.7.3.9

data/lib/molecules/intuition/tools.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 def truncate_string(string, max_length)
-  string.length > max_length ? string.slice(0, max_length) + "." : string
+  string.length > max_length ? string.slice(0, max_length) + '.' : string
 end
 
 size = 33
@@ -53,7 +53,7 @@ class Atome
     def activate_click_analysis
       # the condition below avoid touchdown analysis accumulation
       unless @click_analysis_active
-        # this method analyse all object under the touchdown to find the first user objet and return it's id
+        # this method analyse all object under the touchdown to find the first user object and return it's id
         @click_analysis = lambda { |native_event|
           # the instance variable below check if we can apply tool (cf:  if the atome we don't want to apply tool)
           if Universe.allow_tool_operations
@@ -66,11 +66,12 @@ class Atome
                 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
+                puts 'we have to check if operation is a creation or an alteration to include or exclude the view '
+                # alert atome_touched
+                Universe.active_tools.each do |tool|
+                  # alert "#{tool}, #{atome_found.id}"
+                  apply_tool(tool, atome_found, event)
+                end # if atome_found #&& !atome_found.tag[:system]
 
                 break
               end
@@ -90,6 +91,7 @@ class Atome
     end
 
     def start_click_analysis
+      # here we capture any touch when usingh tool
       @click_analysis_active = false
       JS.global[:document].addEventListener('mouseup') do |native_event|
         Atome.instance_exec(native_event, &@click_analysis) if @click_analysis.is_a?(Proc)
@@ -122,9 +124,9 @@ class Atome
     def creation(current_tool, tool_actions, atome_touched, a_event)
       # we store prev_local_storage prior to lock it to prevent unwanted logs
       # prev_local_storage=Universe.allow_localstorage()
+      @creation_mode = true
       storage_allowed = Universe.allow_localstorage
       Universe.allow_localstorage = false
-
       action_found = tool_actions[:action]
       pre = tool_actions[:pre]
       post = tool_actions[:post]
@@ -155,6 +157,7 @@ class Atome
     end
 
     def apply_tool(tool, atome_touched, a_event)
+
       current_tool = grab(tool)
       tool_actions = current_tool.data
       method_found = tool_actions[:method]
@@ -165,18 +168,22 @@ class Atome
       end
       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)
+      # unless method_found == :alteration && (target.id == :view_color || target.id == :view)
+        unless method_found == :alteration && target.tag[:system]
+
+
+        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
-      send(method_found, current_tool, tool_actions, target, a_event)
+
     end
 
   end
@@ -255,10 +262,10 @@ class Atome
     tool_scheme = @tool_scheme
     tool = self
     tool.active(false)
-    tool.instance_variable_get("@toolbox")&.each do |sub_tool_id|
+    tool.instance_variable_get('@toolbox')&.each do |sub_tool_id|
       toolbox_tool = grab("#{sub_tool_id}_tool")
       toolbox_tool.deactivate_tool
-      # we delete the attached toolbox if it exist
+      # we delete the fasten toolbox if it exist
       toolbox_tool.delete({ force: true })
     end
     grab("#{tool_name}_icon").color(grab(:toolbox_style).data[:text_color])
@@ -277,6 +284,7 @@ class Atome
     # generic behavior
     # we remove touch and resize binding on newly created atomes
     tool.apply(:inactive_tool_col)
+    # alert tool.data[:created]
     tool.data[:created]&.each do |new_atome|
       new_atome.drag(false)
       new_atome.resize(:remove)
@@ -351,8 +359,8 @@ class Atome
 
                                 })
 
-    tool.instance_variable_set("@tool_scheme", tool_scheme)
-    edition = "M257.7 752c2 0 4-0.2 6-0.5L431.9 722c2-0.4 3.9-1.3 5.3-2.8l423.9-423.9c3.9-3.9 3.9-10.2 0-14.1L694.9 114.9c-1.9-1.9-4.4-2.9-7.1-2.9s-5.2 1-7.1 2.9L256.8 538.8c-1.5 1.5-2.4 3.3-2.8 5.3l-29.5 168.2c-1.9 11.1 1.5 21.9 9.4 29.8 6.6 6.4 14.9 9.9 23.8 9.9z m67.4-174.4L687.8 215l73.3 73.3-362.7 362.6-88.9 15.7 15.6-89zM880 836H144c-17.7 0-32 14.3-32 32v36c0 4.4 3.6 8 8 8h784c4.4 0 8-3.6 8-8v-36c0-17.7-14.3-32-32-32z"
+    tool.instance_variable_set('@tool_scheme', tool_scheme)
+    edition = 'M257.7 752c2 0 4-0.2 6-0.5L431.9 722c2-0.4 3.9-1.3 5.3-2.8l423.9-423.9c3.9-3.9 3.9-10.2 0-14.1L694.9 114.9c-1.9-1.9-4.4-2.9-7.1-2.9s-5.2 1-7.1 2.9L256.8 538.8c-1.5 1.5-2.4 3.3-2.8 5.3l-29.5 168.2c-1.9 11.1 1.5 21.9 9.4 29.8 6.6 6.4 14.9 9.9 23.8 9.9z m67.4-174.4L687.8 215l73.3 73.3-362.7 362.6-88.9 15.7 15.6-89zM880 836H144c-17.7 0-32 14.3-32 32v36c0 4.4 3.6 8 8 8h784c4.4 0 8-3.6 8-8v-36c0-17.7-14.3-32-32-32z'
     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 } } })
 
@@ -368,14 +376,14 @@ class Atome
       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|
+        tool_scheme[:particles].each_key do |particle|
           grab("tool_particle_#{particle}").delete({ force: true })
         end
         tool.width(size)
       else
         tool.instance_variable_set('@tool_open', true)
 
-        tool_scheme[:particles].each_with_index do |(particle_name, _value_), ind|
+        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],
@@ -420,9 +428,6 @@ class Atome
             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,
@@ -449,15 +454,13 @@ class Atome
 
                     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 '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)
@@ -472,8 +475,7 @@ class Atome
             end
 
           end
-        end if tool_scheme[:particles]
-        # tool.width(((size + margin) * (tool_scheme[:particles].length + 1)))
+        end
       end
 
     end
@@ -481,8 +483,6 @@ class Atome
       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
@@ -495,7 +495,7 @@ class Atome
           tick[tool_name] = 0
         end
       end
-      puts 'reactivation'
+      # puts 'reactivation'
       tool.instance_variable_set('@prevent_action', false)
     end
 

data/lib/molecules/intuition/utilities.rb

@@ -1,5 +1,114 @@
 # frozen_string_literal: true
 
+class Atome
+
+  def create_new_button(button_id, position_in_menu, label, code)
+    essential_keys = [:inactive, :active]
+    buttons_style = data.select { |key, value| essential_keys.include?(key) }
+    menu_item = box({ id: button_id })
+    menu_item.text({ data: label, id: "#{button_id}_label" })
+    menu_item.code({ button_code: code })
+
+    inactive_style = buttons_style[:inactive]
+    active_style = buttons_style[:active]
+    if active_style
+      active_state_text = active_style[:text]
+      keys_to_exclude = [:margin, :spacing, :disposition, :text]
+      active_style = active_style.reject { |key, _| keys_to_exclude.include?(key) }
+    end
+
+    if inactive_style
+      inactive_state_text = inactive_style[:text]
+      margin = inactive_style[:margin]
+      spacing = inactive_style[:spacing]
+      disposition = inactive_style[:disposition]
+      keys_to_exclude = [:margin, :spacing, :disposition, :text]
+      inactive_style = inactive_style.reject { |key, _| keys_to_exclude.include?(key) }
+      menu_item.set(inactive_style)
+
+      if disposition == :horizontal
+        menu_item.left = margin[:left] + (inactive_style[:width] + spacing) * position_in_menu
+        menu_item.top = margin[:top]
+      else
+        menu_item.top = margin[:top] + (inactive_style[:height] + spacing) * position_in_menu
+        menu_item.left = margin[:left]
+      end
+
+      menu_item.text.each do |text_f|
+        grab(text_f).set(inactive_state_text)
+      end
+
+    end
+
+    menu_item.touch(:down) do
+      unless @active_item == menu_item.id
+        menu_item.set(active_style)
+        menu_item.text.each do |text_f|
+          grab(text_f).set(active_state_text)
+        end
+        fasten.each do |item_id|
+          unless button_id == item_id
+            grab(item_id).remove({ all: :shadow })
+            grab(item_id).set(inactive_style)
+            grab("#{item_id}_label").remove({ all: :shadow })
+            grab("#{item_id}_label").set(inactive_state_text)
+          end
+        end
+        code.call if code
+      end
+      @active_item = menu_item.id
+    end
+  end
+
+  def add_button(params)
+    params.each do |button_id, params|
+      label = params[:text]
+      code = params[:code]
+      # {"new_button"=>{"text"=>"button1", "code"=>#<Proc:0xafe>}}
+      index = fasten.length
+      create_new_button(button_id, index, label, code)
+    end
+    false
+  end
+
+  def resize_matrix(params)
+
+    width(params[:width])
+    height(params[:height])
+    current_matrix = self
+    real_width = current_matrix.to_px(:width)
+    real_height = current_matrix.to_px(:height)
+    spacing = current_matrix.data[:spacing]
+    matrix_cells = current_matrix.data[:matrix]
+
+    total_spacing_x = spacing * (matrix_cells.collect.length ** (0.5) + 1)
+    total_spacing_y = spacing * (matrix_cells.collect.length ** (0.5) + 1)
+
+    if real_width > real_height
+      full_size = real_width
+      available_width = full_size - total_spacing_x
+      available_height = full_size - total_spacing_y
+    else
+      full_size = real_width
+      available_width = full_size - total_spacing_x
+      available_height = full_size - total_spacing_y
+    end
+
+    box_width = available_width / matrix_cells.collect.length ** (0.5)
+    box_height = available_height / matrix_cells.collect.length ** (0.5)
+
+    matrix_cells.collect.each_with_index do |box_id, index|
+      box = grab(box_id)
+      box.width(box_width)
+      box.height(box_height)
+      box.left((box_width + spacing) * (index % matrix_cells.collect.length ** (0.5)) + spacing)
+      box.top((box_height + spacing) * (index / matrix_cells.collect.length ** (0.5)).floor + spacing)
+    end
+
+  end
+
+end
+
 new(molecule: :input) do |params, bloc|
   params[:height] ||= 15
   params[:width] ||= 222
@@ -168,7 +277,7 @@ 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,tag: { system: true } })
+  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,)
@@ -288,81 +397,9 @@ new({ molecule: :slider }) do |params, bloc|
   slider
 
 end
-new(molecule: :button) do |params, bloc|
-  params[:height] ||= 25
-  params[:width] ||= 25
-  states = params.delete(:states) || 1
-  new_id = params.delete(:id) || identity_generator
-
-  back_col = params.delete(:back)
-  back_col ||= :grey
-
-  default_parent = if self.instance_of?(Atome)
-                     id
-                   else
-                     :view
-                   end
-  attach_to = params[:attach] || default_parent
-  renderer_found = grab(attach_to).renderers
-  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,tag: { system: true }
-    })
-  button.remove(:box_color)
-  button.touch(:down) do
-    button.tick(:button)
-    bloc.call((button.tick[:button] - 1) % states)
-
-  end
-
-  params.each do |part_f, val_f|
-    button.send(part_f, val_f)
-  end
-
-  button
-end
 
 new({ particle: :cells })
 
-class Atome
-  def resize_matrix(params)
-
-    width(params[:width])
-    height(params[:height])
-    current_matrix = self
-    real_width = current_matrix.to_px(:width)
-    real_height = current_matrix.to_px(:height)
-    spacing = current_matrix.data[:spacing]
-    matrix_cells = current_matrix.data[:matrix]
-
-    total_spacing_x = spacing * (matrix_cells.collect.length ** (0.5) + 1)
-    total_spacing_y = spacing * (matrix_cells.collect.length ** (0.5) + 1)
-
-    if real_width > real_height
-      full_size = real_width
-      available_width = full_size - total_spacing_x
-      available_height = full_size - total_spacing_y
-    else
-      full_size = real_width
-      available_width = full_size - total_spacing_x
-      available_height = full_size - total_spacing_y
-    end
-
-    box_width = available_width / matrix_cells.collect.length ** (0.5)
-    box_height = available_height / matrix_cells.collect.length ** (0.5)
-
-    matrix_cells.collect.each_with_index do |box_id, index|
-      box = grab(box_id)
-      box.width(box_width)
-      box.height(box_height)
-      box.left((box_width + spacing) * (index % matrix_cells.collect.length ** (0.5)) + spacing)
-      box.top((box_height + spacing) * (index / matrix_cells.collect.length ** (0.5)).floor + spacing)
-    end
-
-  end
-end
-
 new(molecule: :matrix) do |params, &bloc|
   params ||= {}
   # We test if self is main if so we attach the matrix to the view
@@ -428,46 +465,172 @@ new(molecule: :matrix) do |params, &bloc|
   matrix_back
 end
 
-new(molecule: :page) do |params, &bloc|
-  b = box({ color: :red, left: 99, drag: true })
-  b.remove(:box_color)
-  b.text(params)
+new(molecule: :application) do |params, &bloc|
+  params ||= {}
+
+  color({ id: :app_color, red: 0.1, green: 0.3, blue: 0.1 })
+  # TODO : remove the patch below when possible
+  id_f = if params[:id]
+           params.delete(:id)
+         else
+           identity_generator
+         end
+  main_app = box({ id: id_f, width: :auto, height: :auto, top: 0, bottom: 0, left: 0, right: 0, apply: :app_color,
+                   category: :application })
+  main_app.remove(:box_color)
+  main_app.instance_variable_set('@pages', {})
+
+  buttons({
+            id: "#{id_f}_menu",
+            attach: id_f,
+            inactive: { text: { color: :gray }, width: 66, height: 12, spacing: 3, disposition: :horizontal,
+                        color: :orange, margin: { left: 33, top: 12 } },
+            active: { text: { color: :white, shadow: {} }, color: :blue, shadow: {} },
+          })
+  main_app
 end
 
-new(molecule: :application) do |params, &bloc|
+new(molecule: :page) do |params, &bloc|
+  allow_menu = params.delete(:menu)
+  if params[:id]
+    id_f = params.delete(:id)
+    page_name = params.delete(:name)
+    @pages[id_f.to_sym] = params
+  else
+    puts "must send an id"
+  end
+  page_name = page_name || id_f
+  item_code = lambda do
+    show(id_f)
+  end
+  unless allow_menu == false
+    menu_f = grab("#{@id}_menu")
+    menu_f.add_button({ "#{@id}_menu_item_#{page_name}" => {
+      text: page_name,
+      code: item_code
+    } })
+    actor({ "#{@id}_menu_item_#{page_name}" => :buttons })
+    menu_f.role([:button])
+  end
+end
 
-  main_page = box({ drag: true, width: :auto, height: :auto, top: 0, bottom: 0, left: 0, right: 0 })
+new(molecule: :show) do |page_id, &bloc|
+  params = @pages[page_id.to_sym]
+  params ||= {}
+  footer = params.delete(:footer)
+  header = params.delete(:header)
+  left_side_bar = params.delete(:left_side_bar)
+  right_side_bar = params.delete(:right_side_bar)
+  # modules = params.delete(:modules)
+  basic_size = 30
+  fasten.each do |page_id_found|
+    page_found = grab(page_id_found)
+    page_found.delete({ recursive: true }) if page_found && page_found.category.include?(:page)
+  end
+  color({ id: :page_color, red: 0.1, green: 0.1, blue: 0.1 })
+  # TODO : remove the patch below when possible
+  id_f = if params[:id]
+           params.delete(:id)
+         else
+           "#{id_f}_#{identity_generator}"
+         end
+  main_page = box({ width: :auto, depth: -1, height: :auto, id: id_f, top: 0, bottom: 0, left: 0, right: 0, apply: :page_color, category: :page })
   main_page.remove(:box_color)
+
+  main_page.set(params)
+
+  if footer
+    new_footer = box({ left: 0, depth: -1, right: 0, width: :auto, top: :auto, bottom: 0, height: basic_size, category: :footer, id: "#{id_f}_footer" })
+    new_footer.remove(:box_color)
+    new_footer.set(footer)
+  end
+
+  if header
+    new_header = box({ left: 0, right: 0, depth: -1, width: :auto, top: 0, height: basic_size, category: :header, id: "#{id_f}_header" })
+    new_header.remove(:box_color)
+    new_header.set(header)
+  end
+
+  if right_side_bar
+    new_right_side_bar = box({ left: :auto, depth: -1, right: 0, width: basic_size, top: 0, bottom: 0, height: :auto, category: :right_side_bar, id: "#{id_f}_right_side_bar" })
+    new_right_side_bar.remove(:box_color)
+    new_right_side_bar.set(right_side_bar)
+  end
+
+  if left_side_bar
+    new_left_side_bar = box({ left: 0, right: :auto, depth: -1, width: basic_size, top: 0, bottom: 0, height: :auto, category: :left_side_bar, id: "#{id_f}_left_side_bar" })
+    new_left_side_bar.remove(:box_color)
+    new_left_side_bar.set(left_side_bar)
+  end
+
+  fasten.each do |item_id_found|
+    item_found = grab(item_id_found)
+    if item_found&.category&.include?(:footer)
+      main_page.height(:auto)
+      main_page.bottom(item_found.height)
+    end
+    if item_found&.category&.include?(:header)
+      main_page.height(:auto)
+      main_page.top(item_found.height)
+    end
+
+    if item_found&.category&.include?(:right_side_bar)
+      main_page.width(:auto)
+      main_page.left(item_found.width)
+      if footer
+        grab("#{id_f}_footer").right(basic_size)
+      end
+      if header
+        grab("#{id_f}_header").right(basic_size)
+      end
+    end
+
+    if item_found&.category&.include?(:left_side_bar)
+      main_page.width(:auto)
+      main_page.right(item_found.width)
+      if footer
+        grab("#{id_f}_footer").left(basic_size)
+      end
+      if header
+        grab("#{id_f}_header").left(basic_size)
+      end
+    end
+  end
   main_page
+end
+
+new(molecule: :buttons) do |params, &bloc|
+  role_f = params.delete(:role)
+  actor_f = params.delete(:actor)
+  params_saf = deep_copy(params)
+  context = params.delete(:attach) || :view
+  id = params.delete(:id) || identity_generator
+  main = grab(context).box({ id: id })
+  main.role(role_f) || main.role(:buttons)
+  main.actor(actor_f) if actor_f
+  main.color({ blue: 0.5, red: 1, green: 1, alpha: 0 })
+  main.data(params_saf)
+  default = params.delete(:inactive) || {}
+  main.data[:default] = default
+  default_text = default.delete(:text)
+  main.data[:default_text] = default_text
+  active = params.delete(:active) || {}
+  active_text = active.delete(:text)
+  inactive = {}
+  active.each_key do |part_f|
+    inactive[part_f] = default[part_f]
+  end
+  inactive_text = {}
+  active.each_key do |part_f|
+    inactive_text[part_f] = default_text[part_f]
+  end
+
+  params.each_with_index do |(item_id, part_f), index|
+    label = part_f[:text]
+    code = part_f[:code]
+    main.create_new_button(item_id, index, label, code)
+
+  end
+  main
 
-  # def new(params, &bloc)
-  #   if params[:page]
-  #     site_found = grab(params[:page][:application])
-  #     site_found.clear(true)
-  #     page_id = params[:page][:name]
-  #     site_found.box({ id: page_id })
-  #   elsif params[:application]
-  #
-  #     footer_header_size = 33
-  #     footer_header_color = color({ red: 0, green: 0, blue: 0, id: :footer_header_color })
-  #
-  #     if params[:header]
-  #       top = footer_header_size
-  #       header = box({ left: 0, right: 0, width: :auto, top: 0, height: top, id: :header })
-  #       # header.attach(:footer_header_color)
-  #     else
-  #       top = 0
-  #     end
-  #     if params[:footer]
-  #       bottom = footer_header_size
-  #       box({ left: 0, right: 0, width: :auto, top: :auto, bottom: 0, height: bottom, id: :footer })
-  #     else
-  #       bottom = 0
-  #     end
-  #     box({ left: 0, right: 0, width: :auto, top: top, bottom: bottom, height: :auto, id: params[:application] })
-  #   elsif params[:module]
-  #
-  #   end
-  #   super if defined?(super)
-  # end
 end

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

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

data/lib/renderers/html/html.rb

@@ -247,7 +247,19 @@ class HTML
     # JS.eval("atomeJS.connect('ws://#{server}')")
   end
 
+  def transform_to_string_keys_and_values(hash)
+    hash.transform_keys(&:to_s).transform_values do |value|
+      if value.is_a?(Hash)
+        transform_to_string_keys_and_values(value)
+      else
+        value.to_s
+      end
+    end
+  end
+
   def send_message(message)
+    # FIXME  : find why we have to sanitize this message when using ruby wams
+    message = transform_to_string_keys_and_values(message)
     JS.eval("atomeJS.ws_sender('#{message}')")
   end
 
@@ -779,6 +791,7 @@ class HTML
   end
 
   def drag_remove(option)
+
     @draggable = nil
     interact = JS.eval("return interact('##{@id}')")
 
@@ -1380,6 +1393,7 @@ class HTML
   end
 
   def touch_remove(option)
+
     @element[:style][:cursor] = 'default'
     case option
     when :double
@@ -1407,7 +1421,18 @@ class HTML
     else
       # interact = JS.eval("return interact('##{@id}')")
       # interact.unset
-      @original_atome.instance_variable_set('@touch_code', nil)
+      touch_remove(:double)
+      touch_remove(:down)
+      touch_remove(:long)
+      touch_remove(:tap)
+      touch_remove(:touch)
+      touch_remove(:up)
+
+      # @element.removeEventListener('touchstart', onTouchStart);
+      # @element.removeEventListener('touchmove', onTouchMove);
+      # @element.removeEventListener('touchend', onTouchEnd);
+      # console.log("Touch events removed");
+      # @original_atome.instance_variable_set('@touch_code', nil)
     end
 
   end