atome 0.5.7.1.8 → 0.5.7.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0584500fbf0b3f088007209b206d7b6200985b6a7b03c40bddb9ee781bb6697a'
-  data.tar.gz: f0ceedb97e2382612a63a26e00f12eda52e543a84c4d6346c4497ffac9b157fd
+  metadata.gz: 63cd85893b4535b12f8f24da43d2d615234820584a74ae4e4f67c2c1da28068d
+  data.tar.gz: 8c0e70603aee556e09abb0867d0084ccea315d54334ddc6328bf54e8da254a59
 SHA512:
-  metadata.gz: 6265f34e1c06296bd11fcb639a8dcf2553217d6200253617700fc21243bcf6a6c51b82835b7c7318a0bb95558a485eb8a2e28832bd3e3f9d2552d6897409cfa3
-  data.tar.gz: 0d0e50b7c4cb0ef7afd41aaf5a75a1457d63ce9eaabc70b3443af9e2ef75af610b1c86ba0b98dea34b74ce99475827aee86ecf6d1b5bd42896b3c5eaec848b7f
+  metadata.gz: 4f6d187398d27418a21ad283dc4184b0c047635665133fbd05790d49c2592d9213898a6396dfe943a38b68ccda327d205e08d168ef92d7212243a7e1e4b003a2
+  data.tar.gz: 686e3049efeef466841eb3979202d4be3ac753123e419d71a8fb3565159aad2e58ce66e9e28a1de6328243aed298a7480c0ce3504cbc1d00aa3ba80238a0ca5d

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

@@ -8,8 +8,8 @@ new({ particle: :run, category: :utility, type: :boolean }) do |params|
 end
 # new({ particle: :broadcast })
 
-def delete_recursive(atome_id)
-  return if grab(atome_id).tag && (grab(atome_id).tag[:persistent] || grab(atome_id).tag[:system])
+def delete_recursive(atome_id, force=false)
+  return if grab(atome_id).tag && (grab(atome_id).tag[:persistent] || grab(atome_id).tag[:system]) unless force
 
   parent_id_found = grab(atome_id).attach
   parent_found = grab(parent_id_found)
@@ -17,11 +17,11 @@ def delete_recursive(atome_id)
   new_array.delete(atome_id)
   parent_found.instance_variable_set('@attached', new_array)
   grab(atome_id).attached.each do |atome_id_found|
-    delete_recursive(atome_id_found)
+    delete_recursive(atome_id_found, force)
   end
   grab(atome_id).render(:delete, { :recursive => true })
   grab(atome_id).touch(:remove)
-  Universe.delete(atome_id)
+  Universe.delete(grab(atome_id).aid)
 end
 
 new({ particle: :delete, category: :utility, type: :boolean, render: false }) do |params|
@@ -48,6 +48,24 @@ new({ particle: :delete, category: :utility, type: :boolean, render: false }) do
       end
       Universe.delete(@aid)
     end
+  # elsif params == :force
+  #   cells.delete(true)
+  #   group.delete(true)
+  #   # now we detach the atome from it's parent
+  #   # now we init rendering
+  #   render(:delete, params)
+  #   # the machine delete the current atome from the universe
+  #   id_found = @id.to_sym
+  #   if @attach
+  #     parent_found = grab(@attach)
+  #     parent_found.attached.delete(id_found)
+  #   end
+  #   @affect&.each do |affected_atome|
+  #     affected_found = grab(affected_atome)
+  #     affected_found.apply.delete(id_found)
+  #     affected_found.refresh
+  #   end
+  #   Universe.delete(@aid)
   elsif params.instance_of? Hash
     # if we are on a matrix we delete cells found & group found
     cells.delete(true)
@@ -57,14 +75,22 @@ new({ particle: :delete, category: :utility, type: :boolean, render: false }) do
         attached.each do |atttached_atomes|
           delete_recursive(atttached_atomes)
         end
-        # group.each do |el|
-        #   delete_recursive(el)
-        # end
-
         touch(:remove)
         render(:delete, params)
-        Universe.delete(@id)
+        Universe.delete(@aid)
+      end
+    elsif params[:force]
+      attached.each do |atttached_atomes|
+        # alert "attached : #{attached}"
+        delete_recursive(atttached_atomes, true)
       end
+      touch(:remove)
+      render(:delete, params)
+      # alert "Universe : #{Universe.atomes[@aid]}"
+      # alert "length = #{Universe.atomes.length}"
+      Universe.delete(@aid)
+      # alert "Universe : #{Universe.atomes.length}"
+
     else
       # the machine try to find the sub particle id and remove it eg a.delete(monitor: :my_monitor) remove the monitor
       # with id my_monitor

data/lib/atome/kernel/universe.rb

@@ -280,7 +280,7 @@ class Universe
         if @allow_localstorage.include? element
           JS.global[:localStorage].setItem(operation_timing, "{ #{id} => { #{operation} => { #{element} => #{params} } }, sync: false }")
           @history[@history.length] = { operation_timing => { id => { operation => { element => params } }, sync: false, time: Time.now } }
-          puts "===> { #{id} => { #{operation} => { #{element} => #{params} } }, sync: false }"
+          # puts "===> { #{id} => { #{operation} => { #{element} => #{params} } }, sync: false }"
         end
 
 

data/lib/atome/version.rb

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

data/lib/molecules/intuition/tools.rb

@@ -8,9 +8,8 @@ shadow({
          invert: false,
          red: 0, green: 0, blue: 0, alpha: 0.6
        })
-
-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 })
+color({ id: :active_tool_col, alpha: 1, red: 1, green: 1, blue: 1 })
+color({ id: :inactive_tool_col, alpha: 0.1 })
 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: {
@@ -20,13 +19,21 @@ element({ aid: :toolbox_style, id: :toolbox_style, data: {
 } })
 
 class Atome
+  def toolbox(tool_list)
+    @toolbox = tool_list[:tools]
+    tool_list[:tools].each_with_index do |root_tool, index|
+      tools_scheme = Universe.tools[root_tool]
+      build_tool({ name: root_tool, scheme: tools_scheme, index: index, toolbox: tool_list[:toolbox] })
+    end
+  end
+
   class << self
     def init_intuition
       Atome.start_click_analysis
       toolbox_root = Universe.tools_root
       toolbox_root[:tools].each_with_index do |root_tool, index|
         tools_scheme = Universe.tools[root_tool]
-        A.build_tool({ name: root_tool, scheme: tools_scheme, index: index ,toolbox: toolbox_root[:toolbox] })
+        A.build_tool({ name: root_tool, scheme: tools_scheme, index: index, toolbox: toolbox_root[:toolbox] })
       end
     end
 
@@ -35,7 +42,6 @@ class Atome
     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
@@ -50,8 +56,6 @@ class Atome
               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
@@ -83,24 +87,18 @@ class Atome
       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
+            if val.instance_of?(Proc)
+              atome_touched.instance_exec(&val)
+            else
+              atome_touched.send(part, val)
+            end
+            current_tool.data[:treated] << atome_touched if current_tool.data[:treated]
           end
           current_tool.instance_exec(params, &post) if post.is_a? Proc
         end
@@ -124,11 +122,11 @@ class Atome
         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
+          new_atome = if atome_touched
+                        atome_touched.send(atome, temp_val)
+                      else
+                        grab(:view).send(atome, temp_val)
+                      end
           # current_tool.data[:treated] << new_atome
           current_tool.data[:created] << new_atome
           params.delete(:atome_touched)
@@ -152,7 +150,9 @@ 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)
     end
 
@@ -164,13 +164,100 @@ class Atome
 
   def set_action_on_touch(&action)
     @touch_action = action
-
   end
 
   def remove_get_atome_on_touch
     @touch_action = nil
   end
 
+  def activate_tool
+    tool_name = id
+    tool_scheme = @tool_scheme
+    tool = self
+
+    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]
+    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)
+
+    Universe.edit_mode = true
+    # init the tool
+    tool.data[:treated] = []
+    tool.data[:created] = []
+    tool.data[:prev_states] = {}
+    # generic behavior
+    tool.apply(:active_tool_col)
+    Universe.active_tools << tool_name
+    # 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_key do |particle_req|
+        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]
+    unless tool_name.to_sym == :select_tool || !allow_creation || !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
+    end
+
+    # # activate tool analysis test
+    Atome.activate_click_analysis
+    tool.active(true)
+  end
+
+  def deactivate_tool
+    tool_name = id
+    tool_scheme = @tool_scheme
+    tool = self
+    tool.active(false)
+    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
+      toolbox_tool.delete({ force: true })
+    end
+
+    # 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
+      Universe.allow_localstorage = false
+    end
+
+    inactivation_code = tool_scheme[:inactivation]
+    tool.instance_exec(tool.data, &inactivation_code) if inactivation_code.is_a? Proc
+    # 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
+  end
+
   def build_tool(params)
     # here is the main entry for tool creation
     language ||= grab(:view).language
@@ -179,10 +266,10 @@ class Atome
     tool_name = "#{params[:name]}_tool"
     index = params[:index]
     tool_scheme = params[:scheme]
-    toolbox=params[:toolbox] || {}
+    # @tool_scheme=params[:scheme]
+    toolbox = params[:toolbox] || {}
     orientation_wanted = tool_scheme[:orientation] || :sn
-    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]
@@ -190,9 +277,9 @@ class Atome
     case orientation_wanted
     when :sn
       top = :auto
-      bottom_offset=toolbox[:bottom] || 3
+      bottom_offset = toolbox[:bottom] || 3
       spacing = toolbox[:spacing] || 3
-      bottom = index * (size + spacing)+bottom_offset
+      bottom = index * (size + spacing) + bottom_offset
       left = toolbox[:left] || 3
       right = :auto
     when :ns
@@ -222,7 +309,7 @@ class Atome
                                   width: size,
                                   height: size,
                                   smooth: smooth,
-                                  apply: [:tool_inactive_color, :tool_box_border, :tool_shade],
+                                  apply: [:inactive_tool_col, :tool_box_border, :tool_shade],
                                   state: :closed,
                                   data: { method: method,
                                           action: action,
@@ -235,125 +322,30 @@ 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"
+    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= 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, stroke: :black, 'stroke-width' => 37, fill: :white } }})
-    # wait 2 do
-    # alert "#{tool_name}_icon"
-    # alert "current vector : #{grab("#{tool_name}_icon").id}"
-    grab("#{tool_name}_icon").color(:blue)
-    # icon.color(:red)
-    # end
-    # icon= tool_scheme[:icon] || params[:name]
-    # tool.image({path: "medias/images/icons/#{icon}.svg"})
     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
-      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
+      if tool.active == false # first click
+        tool.activate_tool
       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
-        #################################
+        tool.deactivate_tool
         tick[tool_name] = 0
       end
     end
   end
+
 end

data/lib/renderers/html/html.rb

@@ -219,7 +219,6 @@ class HTML
       particles_from_style[key.to_sym] = value if key && value
     end
 
-
     particles_found = particles_found.merge(particles_from_style)
     current_atome = grab(@id)
     usr_bloc.call(particles_found)
@@ -735,7 +734,7 @@ class HTML
   end
 
   def drag_remove(option)
-
+    @draggable = nil
     interact = JS.eval("return interact('##{@id}')")
 
     case option
@@ -745,8 +744,9 @@ class HTML
       @drag_end = ''
     when :move
       interact.draggable(false)
-      interact.unset
+      # interact.unset
       @drag_move = nil
+
     when :locked
       @drag_locked = ''
     when :restrict
@@ -759,7 +759,7 @@ class HTML
       @drag_restrict = ''
       @drag_move = nil
       interact.draggable(false)
-      interact.unset
+      # interact.unset
     end
 
   end
@@ -772,7 +772,7 @@ class HTML
       # 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..
-      @drag_start.call(event) if @drag_start.is_a?(Proc)
+      @drag_start.call(event) if event_validation(@drag_start)
     end
   end
 
@@ -784,38 +784,43 @@ class HTML
       # 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..
-      @drag_end.call(event) if @drag_end.is_a?(Proc)
+      @drag_end.call(event) if event_validation(@drag_end)
     end
   end
 
   def drag_move(_option)
-
+    # the condition below prevent drag accumulation
     interact = JS.eval("return interact('##{@id}')")
-    # interact.draggable(false)
 
-    interact.draggable({
-                         drag: true,
-                         inertia: { resistance: 12,
-                                    minSpeed: 200,
-                                    endSpeed: 100 },
-                       })
+    unless @draggable
+      interact.draggable({
+                           drag: true,
+                           inertia: { resistance: 12,
+                                      minSpeed: 200,
+                                      endSpeed: 100 },
+                         })
+      @drag_move = @original_atome.instance_variable_get('@drag_code')[:move]
+      unless @first_drag
+        interact.on('dragmove') do |native_event|
+          # the use of Native is only for Opal (look at lib/platform_specific/atome_wasm_extensions.rb for more infos)
+          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..
+          @drag_move.call(event) if event_validation(@drag_move)
+          Universe.allow_tool_operations = false
+          dx = event[:dx]
+          dy = event[:dy]
+          x = (@original_atome.left || 0) + dx.to_f
+          y = (@original_atome.top || 0) + dy.to_f
+          @original_atome.left(x)
+          @original_atome.top(y)
+        end
 
-    @drag_move = @original_atome.instance_variable_get('@drag_code')[:move]
-    interact.on('dragmove') do |native_event|
-      # the use of Native is only for Opal (look at lib/platform_specific/atome_wasm_extensions.rb for more infos)
-      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..
-      @drag_move.call(event) if @drag_move.is_a?(Proc)
-      Universe.allow_tool_operations = false
-      dx = event[:dx]
-      dy = event[:dy]
-      x = (@original_atome.left || 0) + dx.to_f
-      y = (@original_atome.top || 0) + dy.to_f
-      @original_atome.left(x)
-      @original_atome.top(y)
+      end
     end
+    @first_drag = true
+    @draggable = true
   end
 
   def drag_restrict(option)
@@ -866,7 +871,7 @@ class HTML
       # 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..
-      @drag_move.call(event) if @drag_move.is_a?(Proc)
+      @drag_move.call(event) if event_validation(@drag_move)
       dx = event[:dx]
       dy = event[:dy]
       x = (@original_atome.left || 0) + dx.to_f
@@ -893,7 +898,7 @@ class HTML
       # 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..
-      @drag_lock.call(event) if @drag_lock.is_a?(Proc)
+      @drag_lock.call(event) if event_validation(@drag_lock)
     end
   end
 
@@ -904,7 +909,7 @@ class HTML
     # 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..
-    bloc.call({ source: draggable_element, destination: dropzone_element }) if bloc.is_a?(Proc)
+    bloc.call({ source: draggable_element, destination: dropzone_element }) if event_validation(bloc)
   end
 
   def drop_activate(_option)
@@ -915,7 +920,7 @@ class HTML
                         accept: nil, # Accept any element
                         overlap: 0.75,
                         ondropactivate: lambda do |native_event|
-                          drop_action(native_event, @drop_activate)
+                          drop_action(native_event, @drop_activate) if event_validation(@drop_activate)
                         end
                       })
   end
@@ -928,7 +933,7 @@ class HTML
                         # overlap: 0.75,
                         # FIXME : remove because os an opal bug since 1.8 reactivate when opal will be debbuged
                         ondropdeactivate: lambda do |native_event|
-                          drop_action(native_event, @drop_deactivate)
+                          drop_action(native_event, @drop_deactivate) if event_validation(@drop_deactivate)
                         end
                       })
   end
@@ -941,7 +946,7 @@ class HTML
                         overlap: 0.75,
                         # FIXME : remove because os an opal bug since 1.8 reactivate when opal will be debbuged
                         ondrop: lambda do |native_event|
-                          drop_action(native_event, @drop_dropped)
+                          drop_action(native_event, @drop_dropped) if event_validation(@drop_dropped)
                         end
                       })
   end
@@ -956,7 +961,7 @@ class HTML
                         overlap: 0.001,
                         # FIXME : remove because os an opal bug since 1.8 reactivate when opal will be debbuged
                         ondragenter: lambda do |native_event|
-                          drop_action(native_event, @drop_enter)
+                          drop_action(native_event, @drop_enter) if event_validation(@drop_enter)
                         end
                       })
   end
@@ -970,7 +975,7 @@ class HTML
                         # overlap: 0.75,
                         # FIXME : remove because os an opal bug since 1.8 reactivate when opal will be debbuged
                         ondragleave: lambda do |native_event|
-                          drop_action(native_event, @drop_leave)
+                          drop_action(native_event, @drop_leave) if event_validation(@drop_enter)
                         end
                       })
 
@@ -990,8 +995,8 @@ class HTML
       @drop_leave = ''
     else
       # to remove all interact event ( touch, drag, scale, ... uncomment below)
-      interact = JS.eval("return interact('##{@id}')")
-      interact.unset
+      # interact = JS.eval("return interact('##{@id}')")
+      # interact.unset
       @drop_activate = ''
       @drop_deactivate = ''
       @drop_dropped = ''
@@ -1025,7 +1030,7 @@ class HTML
                                # 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..
-                               @resize.call(event) if @resize.is_a?(Proc)
+                               @resize.call(event) if event_validation(@resize)
                                x = (@element[:offsetLeft].to_i || 0)
                                y = (@element[:offsetTop].to_i || 0)
                                width = event[:rect][:width]
@@ -1055,7 +1060,7 @@ class HTML
       # 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..
-      @overflow.call({ left: scroll_left, top: scroll_top }) if @overflow.is_a?(Proc)
+      @overflow.call({ left: scroll_left, top: scroll_top }) if event_validation(@overflow)
     end)
   end
 
@@ -1064,12 +1069,11 @@ class HTML
     @over_over = @original_atome.over_code[:over]
     interact.on('mouseover') do |native_event|
       JS.global[:myRubyMouseOverCallback] = Proc.new { @original_atome.over_code[:over].call }
-      JS.eval("document.querySelector('##{@id}').addEventListener('mouseleave', myRubyMouseOverCallback);")
       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..
-      @over_over.call(event) if @over_over.is_a?(Proc)
+      @over_over.call(event) if event_validation(@over_over)
     end
   end
 
@@ -1081,21 +1085,23 @@ class HTML
       # 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..
-      @over_enter.call(event) if @over_enter.is_a?(Proc)
+      @over_enter.call(event) if event_validation(@over_enter)
     end
     @element.addEventListener('mouseenter', @over_enter_callback)
 
   end
 
   def over_leave(_option)
+
     @over_leave = @original_atome.instance_variable_get('@over_code')[:leave]
     return unless @over_leave
 
     @over_leave_callback = lambda do |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..
-      @over_leave.call(event) if @over_leave.is_a?(Proc)
+      @over_leave.call(event) if event_validation(@over_leave)
     end
     @element.addEventListener('mouseleave', @over_leave_callback)
 
@@ -1142,7 +1148,6 @@ class HTML
         # 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..
-        # unless Universe.edit_mode == true
         # @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
@@ -1239,23 +1244,9 @@ class HTML
       @touch_removed[:up] = true
       @touch_up = ''
     else
-      interact = JS.eval("return interact('##{@id}')")
-      interact.unset
-      # @original_atome.instance_variable_set('@touch_code')
-      @original_atome.instance_variable_set('@touch_code', nil)
-      # @touch_removed[:double] = true
-      # @touch_removed[:down] = true
-      # @touch_removed[:long] = true
-      # @touch_removed[:tap] = true
-      # @touch_removed[:up] = true
-      # @touch_double = ''
-      # @touch_down = ''
-      # @touch_long = ''
-      # @touch_tap = ''
-      # @touch_up = ''
-      # to remove all interact event ( touch, drag, scale, ... uncomment below)
       # interact = JS.eval("return interact('##{@id}')")
       # interact.unset
+      @original_atome.instance_variable_set('@touch_code', nil)
     end
 
   end
@@ -1303,14 +1294,13 @@ class HTML
     end
   end
 
-
   # animation below
   def animate(animation_properties)
-    prop= animation_properties[:particle]
-    command = <<~JS 
+    prop = animation_properties[:particle]
+    command = <<~JS
                 var target_div = document.getElementById('#{@id}');
                 window.currentAnimation = popmotion.animate({
-                  from: #{animation_properties[ :from]},
+                  from: #{animation_properties[:from]},
                   to: #{animation_properties[:to]},
                   duration: #{animation_properties[:duration]},
                   onUpdate: function(v) {
@@ -1326,8 +1316,6 @@ class HTML
     JS.eval(command)
   end
 
-
-
   def stop_animation
     JS.eval('if (window.currentAnimation) window.currentAnimation.stop();')
   end

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

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
-
-
+# wait 0.5 do
+#   JS.eval("console.clear()")
+# end
 ########################### Test  check and verification below ############################
 
-new({ tool: :blur }) do |params|
+new({ tool: :combined }) do |params|
 
   active_code = lambda {
     puts :alteration_tool_code_activated
@@ -22,7 +23,7 @@ new({ tool: :blur }) do |params|
   }
 
   zone_spe = lambda { |current_tool|
-    puts "current tool is : #{:current_tool} now creating specific zone"
+    # puts "current tool is : #{:current_tool} now creating specific zone"
     # b = box({ width: 33, height: 12 })
     # b.text({ data: :all })
 
@@ -68,7 +69,6 @@ new({ tool: :box }) do |params|
 
 end
 
-
 new({ tool: :project }) do
   active_code = lambda {
 
@@ -85,32 +85,86 @@ new({ tool: :project }) do
   { activation: active_code }
 end
 
-new({tool: :test}) do
+new({tool: :move}) do
   active_code = lambda {
-    b=grab(:view).box({})
-    b.touch(true) do
-      alert :kool
+    puts 'move activated'
+  }
+  move_code = lambda {
+    drag(true)
+  }
+  inactive_code = lambda {|data|
+     data[:treated].each  do |atome_f|
+       atome_f.drag(false)
+     end
+  }
+
+  { activation: active_code, alteration: { event: move_code }, inactivation: inactive_code }
+end
+
+new({tool: :drag}) do
+  active_code = lambda {
+    puts 'move activated'
+  }
+  move_code = lambda {
+    drag(true) do
+      puts left
     end
   }
-  # active_code=:tito
+
+  { activation: active_code, alteration: { event: move_code} }
+end
+
+new({tool: :touch}) do
+  move_code = lambda {
+    touch(:down) do
+      color(:red)
+    end
+  }
+  { alteration: { event: move_code } }
+end
+
+new({tool: :toolbox1}) do
+  active_code = lambda {
+    toolbox({tools: [:combined],toolbox: { orientation: :ew, left:90 , bottom: 9, spacing: 9} })
+  }
   { activation: active_code }
 end
 
+# Universe.tools_root= {tools: [:blur, :box, :test, :toolbox1],toolbox: { orientation: :ew, left:90 , bottom: 9, spacing: 9} }
+Universe.tools_root= {tools: [:box,:drag,:touch, :move,:toolbox1],toolbox: { orientation: :ew, left:9 , bottom: 9, spacing: 9} }
 
-Universe.tools_root= {tools: [:blur, :box, :test],toolbox: { orientation: :ew, left:9 , bottom: 9, spacing: 9} }
-# Universe.tools_root=[:test]
 Atome.init_intuition
 
-wait 1 do
-  grab(:blur_tool_icon).color(:red)
-  wait 1 do
-    grab(:box_tool_icon).color(:red)
-    wait 1 do
-      grab(:test_tool_icon).color(:red)
-    end
+b=box({id: :the_test__box, selected: true})
+circle({left: 90, id: :the_test_circle, selected: true})
+b.touch(true) do
+  if b.width==170
+    b.width(55)
+  else
+    b.width(170)
   end
+
 end
 
+# box({id: :the_box})
+# circle({left: 90, id: :the_circle})
+# alert b.aid
+
+# b=box
+#
+# active_code = lambda {
+#   b=grab(:view).circle({color: :red, left: 88})
+#   b.touch(true) do
+#     alert :kool
+#   end
+# }
+# b.touch(true) do
+#   # c=circle({color: :red})
+#   active_code.call
+#   # c.touch(true) do
+#   #   # active_code.call
+#   # end
+# end
 
 # ################### check below
 

data/vendor/assets/server/eDen.rb

@@ -16,6 +16,25 @@ class EDen
       Database.db_access
     end
 
+    def email_exist(data, message_id, ws)
+
+      mail = data["email"]
+      puts "mail : #{mail}"
+      db = db_access
+      puts "db : #{db}"
+      user_table = db[:user]
+      puts "user_table : #{user_table}"
+      sanitized_email = sanitize_email(mail)
+      puts "sanitized_email : #{sanitized_email}"
+      user = user_table.where(email: sanitized_email).first
+      puts "user : #{user}"
+      # build the answer telling if email exist or not
+      email_exists_response = !user.nil?
+      puts "email_exists_response : #{email_exists_response}"
+      # response return
+      { data: {email_exist: email_exists_response}, message_id: message_id }
+    end
+
     def terminal(data, message_id, ws)
       { data: { message: `#{data}` }, message_id: message_id }
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atome
 version: !ruby/object:Gem::Version
-  version: 0.5.7.1.8
+  version: 0.5.7.3.0
 platform: ruby
 authors:
 - Jean-Eric Godard
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-30 00:00:00.000000000 Z
+date: 2024-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
@@ -613,6 +613,7 @@ files:
 - vendor/assets/application/examples/online.rb
 - vendor/assets/application/examples/opacity.rb
 - vendor/assets/application/examples/over.rb
+- vendor/assets/application/examples/overflow.rb
 - vendor/assets/application/examples/paint.rb
 - vendor/assets/application/examples/particles.rb
 - vendor/assets/application/examples/percent_to_px.rb
@@ -627,7 +628,6 @@ files:
 - vendor/assets/application/examples/repeat.rb
 - vendor/assets/application/examples/resize.rb
 - vendor/assets/application/examples/rotate.rb
-- vendor/assets/application/examples/scroll.rb
 - vendor/assets/application/examples/security.rb
 - vendor/assets/application/examples/select_text.rb
 - vendor/assets/application/examples/selected.rb