atome 0.5.6.8.7 → 0.5.7.0.3

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

@@ -1,320 +1,666 @@
 # frozen_string_literal: true
 
-# Universe.allow_localstorage = false
+size = 33
+smooth = 3
+shadow({
+         id: :tool_shade,
+         left: 3, top: 3, blur: 3,
+         invert: false,
+         red: 0, green: 0, blue: 0, alpha: 0.6
+       })
 
-color({ id: :creation_layer_col, alpha: 1 })
+color({ id: :tool_inactive_color, red: 1, green: 1, blue: 1, alpha: 0.12 })
+color({ id: :tool_active_color, red: 1, green: 1, blue: 1, alpha: 0.3 })
+border({ id: :tool_box_border, thickness: 1, red: 1, green: 1, blue: 1, alpha: 0.06, pattern: :solid, inside: true })
+# Tool's style object container below
+element({ aid: :toolbox_style, id: :toolbox_style, data: {
+  color: :gray,
+  size: size,
+  smooth: smooth
+} })
 
-b = box({ top: :auto, bottom: 0, id: :box_tool })
+class Atome
+  class << self
+    def init_intuition
+      Atome.start_click_analysis
+      root = [:box, :blur, :drag, :rotate, :select, :move,:project]
+      root.each_with_index do |root_tool, index|
+        tools_scheme = Universe.tools[root_tool]
+        A.build_tool({ name: root_tool, scheme: tools_scheme, index: index })
+      end
+      # Universe.tools.each_with_index do |(tool_name, bloc), index|
+      #
+      #   A.build_tool({ name: tool_name, index: index }, &bloc)
+      # end
+    end
+
+    def selection
+      grab(Universe.current_user).selection.collect
+    end
+
+    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
+        @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
+            event = Native(native_event)
+            x = event[:clientX]
+            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]
+
+                # if atome_found
+                Universe.active_tools.each do |tool|
+                  apply_tool(tool, atome_found, event)
+                end
+                break
+              end
+            end
+          else
+            Universe.allow_tool_operations = true
+          end
+        }
+        @click_analysis_active = true
+      end
+
+    end
+
+    def de_activate_click_analysis
+      @click_analysis = nil
+      @click_analysis_active = false
+    end
+
+    def start_click_analysis
+      @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)
+      end
+    end
+
+    def alteration(current_tool, tool_actions, atome_touched, a_event)
+      if atome_touched
+        storage_allowed = Universe.allow_localstorage
+        action_found = tool_actions[:action]
+        pre = tool_actions[:pre]
+        post = tool_actions[:post]
+        params = { current_tool: current_tool, atome_touched: atome_touched, event: a_event }
+        action_found.each do |part, val|
+          Universe.allow_localstorage = false
+          #################################
+          touch_found = atome_touched.touch
+          touch_procs=atome_touched.instance_variable_get("@touch_code")
+          resize_found = atome_touched.resize
+          resize_procs=atome_touched.instance_variable_get("@resize_code")
+          current_tool.data[:prev_states][atome_touched] = {events: { touch: touch_found, resize: resize_found },
+                                                            procs: {touch_code: touch_procs, resize_code: resize_procs } }
+
+          #################################
+          current_tool.instance_exec(params, &pre) if pre.is_a? Proc
+          Universe.allow_localstorage = storage_allowed
+          if current_tool.data[:allow_alteration]
+            atome_touched.send(part, val)
+            current_tool.data[:treated] << atome_touched
+          end
+          current_tool.instance_exec(params, &post) if post.is_a? Proc
+        end
+
+      end
+    end
+
+    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()
+      storage_allowed = Universe.allow_localstorage
+      Universe.allow_localstorage = false
+
+      action_found = tool_actions[:action]
+      pre = tool_actions[:pre]
+      post = tool_actions[:post]
+      params = { current_tool: current_tool, atome_touched: atome_touched, event: a_event }
+
+      action_found.each do |atome, particle|
+        current_tool.instance_exec(params, &pre) if pre.is_a? Proc
+        temp_val = particle.merge({ resize: true, drag: true, top: a_event[:pageY].to_i, left: a_event[:pageX].to_i })
+        if current_tool.data[:allow_creation]
+          # uncomment the line below if you want to attach to current atome
+          if atome_touched
+            new_atome = atome_touched.send(atome, temp_val)
+          else
+            new_atome = grab(:view).send(atome, temp_val)
+          end
+          # current_tool.data[:treated] << new_atome
+          current_tool.data[:created] << new_atome
+          params.delete(:atome_touched)
+          params[new_atome: new_atome]
+          Universe.allow_localstorage = [atome]
+          Universe.historicize(new_atome.aid, :write, atome, particle)
+        end
+
+      end
+      current_tool.instance_exec(params, &post) if post.is_a? Proc
+      # we restore prev_local_storage to allow logs of drag and resize ...
+      Universe.allow_localstorage = storage_allowed
+    end
+
+    def apply_tool(tool, atome_touched, a_event)
+      current_tool = grab(tool)
+      tool_actions = current_tool.data
+      method_found = tool_actions[:method]
+      unless method_found
+        method_found = :alteration
+        tool_actions[:action] = { noop: true }
+        current_tool.data = tool_actions
+      end
+
+      send(method_found, current_tool, tool_actions, atome_touched, a_event)
+    end
+
+  end
+
+  def noop(_p)
+    # this method is used by tools when no treatment is needed
+  end
+
+  def set_action_on_touch(&action)
+    @touch_action = action
 
-b.touch(:down) do
-  creation_layer = box({ top: 0, left: 0, id: :creation_layer, width: '100%', height: '100%', apply: :creation_layer_col })
-  creation_layer.touch(:down) do |event|
-    left_found = event[:pageX].to_i
-    top_found = event[:pageY].to_i
-    box({ left: left_found, top: top_found ,id: "tutu_#{Universe.atomes.length}", color: :red})
-    creation_layer.delete(true)
-    creation_layer.touch({ remove: :down })
-    puts Universe.atomes.length
-    puts "=> #{Universe.user_atomes}"
+  end
+
+  def remove_get_atome_on_touch
+    @touch_action = nil
+  end
+
+  def build_tool(params)
+    label = params[:name]
+    tool_name = "#{params[:name]}_tool"
+    index = params[:index]
+    orientation_wanted = :sn
+    tool_scheme = params[:scheme]
+    color({ id: :active_tool_col, alpha: 1, red: 1, green: 1, blue: 1 })
+    color({ id: :inactive_tool_col, alpha: 0.6 })
+    grab(:intuition).storage[:tool_open] ||= []
+    grab(:intuition).storage[:tool_open] << tool_name
+    size = grab(:toolbox_style).data[:size]
+    smooth = grab(:toolbox_style).data[:smooth]
+    case orientation_wanted
+    when :sn
+      top = :auto
+      bottom = index * (size + 3)
+      left = 0
+      right = :auto
+    when :ns
+    when :ew
+    when :we
+    else
+      #
+    end
+
+    # tool creation
+    if tool_scheme[:creation]
+      action = tool_scheme[:creation]
+      method = :creation
+    end
+    if tool_scheme[:alteration]
+      action = tool_scheme[:alteration]
+      method = :alteration
+    end
+
+    tool = grab(:intuition).box({ id: tool_name,
+                                  tag: { system: true },
+                                  # orientation: orientation_wanted,
+                                  top: top,
+                                  bottom: bottom,
+                                  left: left,
+                                  right: right,
+                                  width: size,
+                                  height: size,
+                                  smooth: smooth,
+                                  apply: [:tool_inactive_color, :tool_box_border, :tool_shade],
+                                  state: :closed,
+                                  data: { method: method,
+                                          action: action,
+                                          allow_alteration: true,
+                                          allow_creation: true,
+                                          # activation: tool_scheme[:activation],
+                                          #  inactivation: tool_scheme[:inactivation], zone: tool_scheme[:zone],
+                                          post: tool_scheme[:post],
+                                          pre: tool_scheme[:pre],
+                                  }
+
+                                })
+    tool.vector({ tag: { system: true }, left: 9, top: :auto, bottom: 9, width: 18, height: 18, id: "#{tool_name}_icon" })
+    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.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
+      tick(tool_name)
+      # active code exec
+      if tick[tool_name] == 1 # first click
+        events_allow = [:top, :left, :right, :bottom, :width, :height]
+        alterations = tool_scheme[:alteration] ? tool_scheme[:alteration].keys : []
+        creations = tool_scheme[:creation] ? tool_scheme[:creation].keys : []
+        prev_auth = Universe.allow_localstorage ||= []
+        storage_allowed = events_allow.concat(alterations).concat(creations).concat(prev_auth).uniq
+        Universe.allow_localstorage = storage_allowed
+        # we set edit mode to true (this allow to prevent user atome to respond from click)
+        Universe.edit_mode = true
+        Universe.active_tools << tool_name
+        # init the tool
+        tool.data[:treated] = []
+        tool.data[:created] = []
+        tool.data[:prev_states] = {}
+        # generic behavior
+        tool.apply(:active_tool_col)
+        # activation code
+        activation_code = tool_scheme[:activation]
+        tool.instance_exec(&activation_code) if activation_code.is_a? Proc
+        # below we the particles of selected atomes to feed tools values
+        # possibility 1 (pipette like):
+        # now we get the values from selected atomes
+        Atome.selection.each do |atome_id_to_treat|
+          tool.data[:action].each do |particle_req, value_f|
+            unless Universe.atome_preset
+              value_found = grab(atome_id_to_treat).send(particle_req)
+              if value_found
+                tool.data[:action][particle_req] = value_found
+              else
+              end
+            end
+          end
+        end
+        # possibility 2  (immediate apply):
+        allow_creation = tool.data[:allow_creation]
+        allow_alteration = tool.data[:allow_alteration]
+        Atome.selection.each do |atome_id_to_treat|
+          atome_found = grab(atome_id_to_treat)
+          event = { pageX: 0, pageY: 0, clientX: 0, clientY: 0 }
+          Atome.apply_tool(tool_name, atome_found, event)
+        end unless tool_name.to_sym == :select_tool || !allow_creation || !allow_alteration
+
+        # activate tool analysis test
+        Atome.activate_click_analysis
+      else
+        Universe.allow_localstorage = false
+        # 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
+        if Universe.active_tools.length == 0
+          Atome.de_activate_click_analysis
+          Universe.edit_mode = false
+        end
+
+        inactivation_code = tool_scheme[:inactivation]
+        tool.instance_exec(tool.data, &inactivation_code) if inactivation_code.is_a? Proc
+        # end if tool_content && tool_content[:inactive]
+
+        # generic behavior
+        # we remove touch and resize binding on newly created atomes
+        tool.apply(:inactive_tool_col)
+        tool.data[:created].each do |new_atome|
+          new_atome.drag(false)
+          new_atome.resize(:remove)
+        end
+        ################################
+        # we restore prev touch and resize
+        tool.data[:prev_states].each do |atome_f, prev_par|
+          puts prev_par
+
+          # params[:events].each do |part_f, val_f|
+          #   # alert "@#{part_f}, #{part_f}"
+          #   atome_f.send(part_f, val_f)
+          # end
+          # alert "--> params :  #{params[:events]}"
+          # alert "--> procs :  #{params[:procs][params[:events]]}"
+           # atome_f.touch(false)
+          # atome_f.touch(true) do
+          #   alert :kool
+          # end
+          # alert params[:procs]
+          # params[:procs].each do |var_n, procs_f|
+          #   # procs_f.each do |action_f, proc|
+          #   #   # puts "#{var_n}==> #{action_f}, #{proc}"
+          #   # end
+          #   puts "==> #{var_n}, #{proc_f}"
+          #   # atome_f.instance_variable_set("@#{var_n}", proc_f)
+          # end
+          # atome_f.touch(false)
+          # alert "#{atome_f.touch} : #{atome_f.instance_variable_get("@touch_code")}"
+        end
+
+        # atome_f.touch(touch_found)
+        # atome_f.resize(resize_found)
+        # inactivation code
+        #################################
+        tick[tool_name] = 0
+      end
+    end
   end
 end
 
+module Intuition
+  class << self
+    @toolbox = { impulse: [:capture_tool, :communication_tool, :creation_tool, :view_tool, :time_tool, :find_tool, :home_tool],
+                 capture_tool: [:microphone_tool, :camera_tool,]
+    }
 
-#
-# ######################
-#
-# # frozen_string_literal: true
-# class Atome
-#
-#   def build_tool(&bloc)
-#     # alert params[:tool]
-#     a = Atome.instance_exec(&bloc)
-#     puts "===> a is : #{a[:action]}"
-#     # check below
-#     # wait 2 do
-#     #   send a[:action]
-#     # end
-#     grab(:toolbox).box({color: :white, width: Intuition.style[:tool][:width], height: Intuition.style[:tool][:width]})
-#   end
+    def intuition_int8
+      # tool taxonomy and list
+      {
+        capture: { int8: { french: :enregistrement, english: :record, german: :datensatz } },
+        communication: { french: :communication, english: :communication, german: :communication },
+        tool: { french: :outils, english: :tools, german: :werkzeuge },
+        view: { french: :vue, english: :view, german: :aussicht },
+        time: { french: :horloge, english: :clock, german: :Uhr },
+        find: { french: :trouve, english: :find, german: :finden },
+        home: { french: :accueil, english: :home, german: :zuhause },
+        code: { french: :code, english: :code, german: :code },
+        impulse: { french: :impulse, english: :impulse, german: :impulse },
+      }
+    end
+
+  end
+
+end
+
+# ##############################################################################################
+
+new({ tool: :blur }) do |params|
+
+  active_code = lambda {
+    puts :alteration_tool_code_activated
+  }
+
+  inactive_code = lambda { |param|
+    puts :alteration_tool_code_inactivated
+  }
+  pre_code = lambda { |params|
+    puts "pre_creation_code,atome_touched: #{:params}"
+
+  }
+  post_code = lambda { |params|
+    puts "post_creation_code,atome_touched: #{:params}"
+
+  }
+
+  zone_spe = lambda { |current_tool|
+    puts "current tool is : #{:current_tool} now creating specific zone"
+    # b = box({ width: 33, height: 12 })
+    # b.text({ data: :all })
+
+  }
+
+  {
+    activation: active_code,
+    inactivation: inactive_code,
+    alteration: { width: 22, blur: 3 },
+    pre: pre_code,
+    post: post_code,
+    zone: zone_spe,
+    int8: { french: :couleur, english: :color, german: :colorad } }
+
+end
+
+new({ tool: :box }) do |params|
+
+  active_code = lambda {
+    puts :creation_tool_code_activated
+  }
+
+  inactive_code = lambda { |atomes_treated|
+    puts :creation_tool_code_inactivated
+
+  }
+  pre_creation_code = lambda { |params|
+    puts "pre_creation_code : atome_touched : #{:params} "
+
+  }
+
+  post_creation_code = lambda { |params|
+    puts "post_creation_code,atome_touched: #{:params}"
+  }
+
+  { creation: { box: { color: :blue, width: 66, height: 66 } },
+    activation: active_code,
+    inactivation: inactive_code,
+    pre: pre_creation_code,
+    post: post_creation_code,
+    int8: { french: :formes, english: :shape, german: :jesaispas } }
+
+end
+
+new({ tool: :drag }) do |params|
+
+  active_code = lambda {
+    # Atome.selection.each do |atome_id_to_treat|
+    #   # reinit first to avoid multiple drag event
+    #   grab(atome_id_to_treat).drag(false)
+    # end
+    # drag_remove
+    # puts :alteration_tool_code_activated
+  }
+
+  inactive_code = lambda { |param|
+    # puts :alteration_tool_code_inactivated
+  }
+  pre_code = lambda { |params|
+    atome_target = params[:atome_touched]
+    # puts  "==> #{atome_target.drag}"
+    if atome_target.drag
+      atome_target.drag(false)
+    else
+      atome_target.drag(true)
+    end
+
+  }
+  post_code = lambda { |params|
+    # puts "post_creation_code,atome_touched: #{params}"
+
+  }
+
+  zone_spe = lambda { |current_tool|
+    # puts "current tool is : #{current_tool} now creating specific zone"
+    # b = box({ width: 33, height: 12 })
+    # b.text({ data: :all })
+
+  }
+
+  {
+    activation: active_code,
+    inactivation: inactive_code,
+    # alteration: { drag: true },
+    pre: pre_code,
+    post: post_code,
+    zone: zone_spe,
+    int8: { french: :drag, english: :drag, german: :drag } }
+
+end
+
+new({ tool: :select }) do |params|
+  pre_code = lambda { |param|
+    atome_touched = param[:atome_touched]
+    current_tool = param[:current_tool]
+    if atome_touched.selected
+      atome_touched.selected(false)
+      current_tool.data[:allow_alteration] = false
+    else
+      # alert atome_touched.selected
+      # alert Atome.selection
+      atome_touched.selected(true)
+      # alert atome_touched.selected
+
+      current_tool.data[:allow_alteration] = true
+    end
+  }
+  {
+    pre: pre_code,
+    alteration: { selected: true },
+    int8: { french: :select, english: :select, german: :select }
+  }
+end
+
+new({ tool: :rotate }) do
+  { alteration: { height: 150, rotate: 45 } }
+end
+new({ tool: :move }) do |params|
+  active_code = lambda {
+    # if  Atome.selection.instance_of? Array
+    # end
+    Atome.selection.each do |atome_id_to_treat|
+    # #   # reinit first to avoid multiple drag event
+    # #   grab(atome_id_to_treat).drag(false)
+    end
+    # drag_remove
+    # puts :alteration_tool_code_activated
+  }
+
+  inactive_code = lambda { |params|
+    # we remove drag
+    params[:treated].each do |atome_f|
+      atome_f.drag(false)
+    end
+    # puts :alteration_tool_code_inactivated
+
+  }
+  pre_code = lambda { |params|
+    atome_target = params[:atome_touched]
+    # puts  "==> #{atome_target.drag}"
+    if atome_target.drag
+      # atome_target.drag(false)
+    else
+      atome_target.drag(true)
+    end
+
+  }
+  post_code = lambda { |params|
+
+    # puts "post_creation_code,atome_touched: #{params}"
+
+  }
+
+  zone_spe = lambda { |current_tool|
+    # puts "current tool is : #{current_tool} now creating specific zone"
+    # b = box({ width: 33, height: 12 })
+    # b.text({ data: :all })
+
+  }
+
+  {
+    activation: active_code,
+    inactivation: inactive_code,
+    # alteration: { drag: true },
+    pre: pre_code,
+    post: post_code,
+    zone: zone_spe,
+    int8: { french: :drag, english: :drag, german: :drag } }
+
+end
+new({ tool: :project }) do
+  active_code = lambda {
+
+    alert :get_projects_now
+    # if  Atome.selection.instance_of? Array
+    # end
+    # Atome.selection.each do |atome_id_to_treat|
+    #   # #   # reinit first to avoid multiple drag event
+    #   # #   grab(atome_id_to_treat).drag(false)
+    # end
+    # drag_remove
+    # puts :alteration_tool_code_activated
+  }
+  { activation: active_code }
+end
+# new({ tool: :move }) do
+#   inactivate=lambda{|param|
+#      param[:treated].each do |atome_f|
+#        atome_f.drag(false)
+#      end
+#   }
+#   { alteration: { drag: true, left: nil , top: nil}, inactivation: inactivate }
 # end
-#
-# class Object
-#   def new(params, &bloc)
-#     # Genesis = Genesis.Genesis
-#     if params.key?(:atome)
-#       Universe.add_atomes_specificities params[:atome]
-#       Genesis.build_atome(params[:atome], &bloc)
-#     elsif params.key?(:particle)
-#       Atome.instance_variable_set("@main_#{params[:particle]}", bloc)
-#       # render indicate if the particle needs to be rendered
-#       # store tell the system if it need to store the particle value
-#       # type help the system what type of type the particle will receive and store
-#       Genesis.build_particle(params[:particle], { render: params[:render], return: params[:return],
-#                                                   store: params[:store], type: params[:type] }, &bloc)
-#     elsif params.key?(:sanitizer)
-#       Genesis.build_sanitizer(params[:sanitizer], &bloc)
-#     elsif params.key?(:pre)
-#       Atome.instance_variable_set("@pre_#{params[:pre]}", bloc)
-#     elsif params.key?(:post)
-#       Atome.instance_variable_set("@post_#{params[:post]}", bloc)
-#     elsif params.key?(:after)
-#       Atome.instance_variable_set("@after_#{params[:after]}", bloc)
-#     elsif params.key?(:read)
-#       Atome.instance_variable_set("@read_#{params[:read]}", bloc)
-#     elsif params[:renderer]
-#       renderer_found = params[:renderer]
-#       if params[:specific]
-#         Universe.set_atomes_specificities(params)
-#         params[:specific] = "#{params[:specific]}_"
-#       end
-#       render_method = "#{renderer_found}_#{params[:specific]}#{params[:method]}"
-#       Genesis.build_render(render_method, &bloc)
-#     elsif params.key?(:callback)
-#       particle_targetted = params[:callback]
-#       Atome.define_method "#{particle_targetted}_callback" do
-#         bloc.call
-#       end
-#     elsif params.key?(:tool)
-#       A.build_tool(&bloc)
-#     end
-#   end
+### tool2 test
+
+Atome.init_intuition
+
+# ###################
+
+b = box({ left: 123, top: 66, selected: false, id: :the_box, color: :green })
+b.touch(:down) do
+  puts " on touch : #{Universe.allow_localstorage}"
+end
+b.resize(true) do
+  puts :good!
+end
+the_circ = circle({ left: 123, top: 120, selected: false, id: :the_circle })
+
+the_circ.touch(:down) do |params|
+  puts " down : params: #{params}, id: #{the_circ.id}"
+end
+
+the_circ.touch(:up) do
+  puts "up :kool"
+end
+the_circ.drag(true) do
+  puts "drag : now"
+end
+
+bb = box({ left: 333, width: 120, selected: false, id: :big_box })
+
+b = box({ id: :the_big_boxy })
+# text({ data: :hello, selected: true, left: 120, id: :texting, blur: 12 })
+# text({data: :hello, left: 120, id: :texting})
+# Universe.tools.each_with_index do |(tool_name, bloc), index|
+#  Atome.instance_exec(&bloc) if bloc.is_a?(Proc)
+#   # alert "#{tool_name} : #{tool_content}"
+#   # alert b.id
 # end
-#
-#
-# def record_tool
-#   grab(Universe.current_user).selection
-#   alert "must get selection to treat it "
+
+# wait 2 do
+#   # c.preset( {:box=>{:width=>39, :height=>39, :apply=>[:box_color], :left=>0, :top=>0}} )
+#   c.preset( :box )
 # end
-#
-#
-# module Intuition
-#   class << self
-#     def style
-#       size=39
-#       style={}
-#       style[:toolbox]={width: size}
-#       style[:toolbox]={height: size}
-#       style[:tool]={width: size}
-#       style[:tool]={height: size}
-#
-#       style
-#     end
-#     def intuition_int8
-#       # tool taxonomy and list
-#       {
-#         capture: { int8: { french: :enregistrement, english: :record, german: :datensatz } },
-#         communication: { french: :communication, english: :communication, german: :communication },
-#         tool: { french: :outils, english: :tools, german: :werkzeuge },
-#         view: { french: :vue, english: :view, german: :aussicht },
-#         time: { french: :horloge, english: :clock, german: :Uhr },
-#         find: { french: :trouve, english: :find, german: :finden },
-#         home: { french: :accueil, english: :home, german: :zuhause },
-#         code: { french: :code, english: :code, german: :code },
-#         impulse: { french: :impulse, english: :impulse, german: :impulse },
-#       }
-#     end
-#     def intuition_taxonomy
-#
-#     end
-#
-#     def impulse
-#       # tool start point
-#       [:capture, :communication, :tool, :view, :time, :find, :home]
+# b=box({left: 333, top: 333})
+# b.touch(true) do
+#   alert Atome.selection
+# end
+# grab(:the_texting).color(:white)
+# grab(:the_texting).left(33)
+# grab(:the_texting).top(133)
+# grab(:the_texting).width(133)
+# grab(:the_texting).top(133)
+# grab(:the_texting).data(:kool)
+# grab(:the_texting).type(:text)
+# grab(:the_texting).rotate(:text)
+
+# b=box
+# b.touch(true) do
+#   puts :ok
+#   # alert b.instance_variable_get('@touch')
+#   # alert b.instance_variable_get('@touch_code')
+#   b.touch(false)
+#   wait 3 do
+#     puts :ready
+#     b.touch(true) do
+#       puts :kool
 #     end
+#     # alert b.touch
+#     # alert b.instance_variable_get('@touch')
+#     # alert b.instance_variable_get('@touch_code')
 #   end
-#
-#
-#   # def capture
-#   #   categories=ATOME.methods_categories
-#   #   [categories[:inputs]]
-#   # end
-#   #
-#   # def communication
-#   #   categories=ATOME.methods_categories
-#   #   [categories[:communications]]
-#   # end
-#   #
-#   # def toolz
-#   #   categories=ATOME.methods_categories
-#   #   [categories[:spatials],categories[:helpers],categories[:materials],
-#   #    categories[:geometries],categories[:effects],
-#   #    categories[:medias],categories[:hierarchies],categories[:utilities],categories[:events]]
-#   # end
-#   #
-#   # def tool_style(size = 33)
-#   #   # styling
-#   #   shadows = [{ x: size / 15, y: size / 15, thickness: 0, blur: size / 3, color: { red: 0, green: 0, blue: 0, alpha: 0.3 } }, { x: -size / 15, y: -size / 15, thickness: 0, blur: size / 6, color: { red: 1, green: 1, blue: 1, alpha: 0.3 } }]
-#   #   style = { type: :tool, content: { points: 4 }, color: { red: 0.9, green: 0.9, blue: 0.9, alpha: 0.15 }, parent: :intuition, shadow: shadows, blur: { value: 6, invert: true } }
-#   #   return style
-#   # end
-#   #
-#   # def open_tool(tool_id, widthness=3, orientation=:x, speed=0.6)
-#   #   if orientation == :x
-#   #     orientation = :width
-#   #     value = grab(tool_id).width
-#   #   else
-#   #     orientation = :height
-#   #     value = grab(tool_id).height
-#   #   end
-#   #   animate({
-#   #             start: { orientation => value },
-#   #             end: { orientation => value * widthness },
-#   #             duration: speed * 1000,
-#   #             loop: 0,
-#   #             curve: :easing,
-#   #             target: tool_id
-#   #           })
-#   #   notification "find why this id #{self.atome_id}, add annimation callback to set overflow when anim complete"
-#   #   grab(tool_id).overflow(:visible)
-#   # end
-#   #
-#   # def close_tool(tool_id, widthness, orientation, speed)
-#   #   if orientation == :x
-#   #     orientation = :width
-#   #     value = grab(tool_id).width
-#   #   else
-#   #     orientation = :height
-#   #     value = grab(tool_id).height
-#   #   end
-#   #   animate({
-#   #             start: { orientation => value * widthness },
-#   #             end: { orientation => value },
-#   #             duration: speed * 1000,
-#   #             loop: 0,
-#   #             curve: :easing,
-#   #             target: tool_id
-#   #           })
-#   #   # grab(tool_id).overflow(:hidden)
-#   # end
-#   #
-#   # def create_tool(tool_name, size = 33, x_pos = 0, y_pos = 33, offsset=0)
-#   #   tool_created = tool(self.tool_style(size).merge({ parent: :main_menu, atome_id: "tool_" + tool_name, id: "tool_" + tool_name,
-#   #                                                     width: size, height: size, smooth: size / 9, overflow: :hidden, x: x_pos, y: y_pos, z: 1, content: [] }))
-#   #   icon=tool_created.shape({ path: tool_name, width: size - size / 2, height: size - size / 2, center: true })
-#   #   # name = intuition_list[tool_name][language]
-#   #   particle({ atome_id: :tools_property_container, color: { red: 0.6, green: 0.6, blue: 0.6 } })
-#   #   # we get the plugin code only if the plugin hasn't been interpreted before (unless condition below)
-#   #   unless grab(:intuition).content.include? tool_name
-#   #     ATOME.reader("./medias/e_rubies/tools/#{tool_name}.rb") do |data|
-#   #       #  todo add a security parser here
-#   #       # we set the variable tool that can be used to facilitate plugin creation
-#   #       data="tool=grab(:#{tool_created.atome_id})\n"+data
-#   #       compile(data)
-#   #       # we add the tool to the intuition content so it won't be loaded twice
-#   #       grab(:intuition).content |= [tool_name]
-#   #     end
-#   #   end
-#   #   # end
-#   #   tool_created.active({ exec: false })
-#   #   tool_created.inactive({ exec: false })
-#   #   icon.touch(stop: true) do
-#   #     if tool_created.active[:exec] == true
-#   #       tool_created.color(:transparent)
-#   #       tool_created.active(exec: false, proc: tool_created.active[:proc]  )
-#   #       tool_created.inactive(exec: true, proc: tool_created.inactive[:proc]  )
-#   #     else
-#   #       tool_created.color({alpha: 0.3})
-#   #       tool_created.active({ exec: true, proc: tool_created.active[:proc]  })
-#   #     end
-#   #   end
-#   # end
-#   #
-#   # # we get menu entry point
-#   # def open_intuition(position = {})
-#   #   position = { x: 0, yy: 0, size: 33, orientation: :vertical, offset: 0 }.merge(position)
-#   #   # we get content language from view's language
-#   #   if grab(:main_menu)
-#   #     grab(:main_menu).delete
-#   #   else
-#   #     grab(:view).language
-#   #     self.language(grab(:view).language)
-#   #     orientation = position.delete(:orientation)
-#   #     size = position.delete(:size)
-#   #     offset = position.delete(:offset)
-#   #     # positioning and scaling
-#   #     if orientation == :vertical
-#   #       requested_width = size
-#   #       requested_height = (size+offset)* impulse.length
-#   #     else
-#   #       requested_width = (size+offset) * impulse.length
-#   #       requested_height = size
-#   #     end
-#   #     tool({ atome_id: :main_menu, parent: :intuition, color: { alpha: 0 } }.merge(position).merge(width: requested_width, height: requested_height))
-#   #     impulse.each_with_index do |item, index|
-#   #       if orientation == :vertical
-#   #         create_tool(item, size, 0, index * (size+offset))
-#   #       else
-#   #         create_tool(item, size, index * (size+offset), 0)
-#   #       end
-#   #     end
-#   #   end
-#   # end
-# end
-# # atome class extension for eVe
-#
-# class Atome
-#   include Intuition
-#   #  def atome(requested_property)
-#   #    # add component list iin the content we maybe ahave to create a tool object because box can't handle this type of content
-#   #    new_atome=self.tool({ atome_id: "#{self.atome_id}_#{requested_property}_atome_#{self.content.length}", x: 66})
-#   #    new_atome.touch({ stop: true, option: :down}) do
-#   #      color(:red)
-#   #      new_atome.height = new_atome.height*3
-#   #    end
-#   #    new_atome.touch({ stop: true, option: :up}) do
-#   #      color(:red)
-#   #      new_atome.height = new_atome.height/3
-#   #    end
-#   #    notification "now we have to add an object or a new property (style) to store complete tool style including size and
-#   # orientation so we can position the new atome correctly"
-#   #    # alert self.content.class
-#   #    # alert self.content.length
-#   #    # alert tool_style
-#   #  end
 # end
-#
-# # # we initialise the toolbox here :
-# #
-# # # the launch bar
-# # launch_bar = box({ x: 0, y: 0, width: 33, height: "100%", parent: :intuition, z: 0, color: { alpha: 0 } })
-# # launch_bar.touch({ option: :long }) do |evt|
-# #   size = 33
-# #   yy_touch_position = grab(:view).convert(:height) - evt.page_y
-# #   if yy_touch_position < size
-# #     #if the long touch is within the wanted area( in this  at bottom of the screen) we open the menu
-# #     # launch_bar.open_intuition({ x: size, yy: 6,offset: 6, orientation: :horizontal, size: size })
-# #     launch_bar.open_intuition({ x: 6, yy: size,offset: 6, orientation: :vertical, size: size })
-# #   end
-# # end
-# #
-# # # # # # # # # # # # # # # # tests below   # # # # # # # # # # # # #
-# #
-# # list = molecule_analysis(@molecules_list)
-# # notif list[:tools]
-# # notif "======"
-# # notif list[:molecules]
-# # notif "======"
-# # notif list[:atomes]
-# # notif "======"
-# # notif list[:molecules][:shadow]
-# # let's build the toolbox
-# grab(:intuition).box({id: :toolbox, top: :auto, bottom: 0, left: 0, width: Intuition.style[:toolbox][:width], height: 255})
-#
-# # tool builder
-#
-# new({ tool: :capture }) do |params|
-#   tool = { id: :rec_01,
-#            name: :record, icon: :record, action: {open: [:sub_menu]},  code: :record_tool, position: { root: 1 }, # position can be multiple
-#            option: { opt1: :method_2 }, int8: { french: :enregistrement, english: :record, german: :datensatz } }
-#   tool
-# end
-# # Intuition::toolbox_style
-# # Intuition.toolbox_style
-# # puts A.impulse
-# # def fill_toolzone(tools_ids)
-# #
-# # end
-# #
-# # fill_toolzone(%i[files edition select group link copy undo settings])
-#
+
+# A.html.record
+
+# A.html.record
+
+