atome 0.5.7.3.6 → 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
@@ -442,29 +479,39 @@ new(molecule: :application) do |params, &bloc|
                    category: :application })
   main_app.remove(:box_color)
   main_app.instance_variable_set('@pages', {})
-  menu = params.delete(:menu)
-  main_app.box(menu.merge({ id: "#{id_f}_menu" })) if menu
-  params.each do |part_f, val_f|
-    main_app.send(part_f, val_f)
-  end
+
+  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: :page) do |params, &bloc|
+  allow_menu = params.delete(:menu)
   if params[:id]
     id_f = params.delete(:id)
-    page_name=params.delete(:name)
+    page_name = params.delete(:name)
     @pages[id_f.to_sym] = params
   else
     puts "must send an id"
   end
-  page_name= page_name || id_f
-  menu_f= grab("#{@id}_menu")
-  page_title=menu_f.text({ data: page_name })
-  page_title.touch(:down) do
+  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
 
 new(molecule: :show) do |page_id, &bloc|
@@ -476,9 +523,8 @@ new(molecule: :show) do |page_id, &bloc|
   right_side_bar = params.delete(:right_side_bar)
   # modules = params.delete(:modules)
   basic_size = 30
-  attached.each do |page_id_found|
+  fasten.each do |page_id_found|
     page_found = grab(page_id_found)
-    # puts "#{page_id_found} : #{page_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 })
@@ -517,7 +563,7 @@ new(molecule: :show) do |page_id, &bloc|
     new_left_side_bar.set(left_side_bar)
   end
 
-  attached.each do |item_id_found|
+  fasten.each do |item_id_found|
     item_found = grab(item_id_found)
     if item_found&.category&.include?(:footer)
       main_page.height(:auto)
@@ -551,4 +597,40 @@ new(molecule: :show) do |page_id, &bloc|
     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
+
 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

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

@@ -0,0 +1,35 @@
+# # frozen_string_literal: true
+b=box
+
+b.touch(:down) do
+   A.message({ action: :authentication, data: { table: :user, particles: { email: 'tre@tre.tre', password: 'poipoi' } } }) do |response|
+    alert "=> #{response}"
+  end
+end
+
+#
+#
+# # # 1 login attempt
+
+wait 1 do
+  A.message({ action: :authentication, data: { table: :user, particles: { email: 'tre@tre.tre', password:  'poipoi' } } }) do |response|
+    alert "=> #{response}"
+  end
+  wait 1 do
+    A.message({ action: :authentication, data: { table: :user, particles: { email: 'tre@tre.tre', password:  'poipoi' } } }) do |response|
+      alert "=> #{response}"
+    end
+  end
+end
+#
+# 2 account creation attempt
+# wait 1 do
+#   A.message({ action: :account_creation, data: { email: 'tre@tre.tre', password: 'poipoi', user_id: 'Nico' }  }) do |response|
+#     puts response
+#   end
+#
+# end
+
+# string=hello
+#
+# puts JS.global.sha256(string.to_s)

data/vendor/assets/application/examples/actor&role.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+bbb = box({left: 66})
+ccc = bbb.circle(id: :the_circle)
+
+bbb.role(:first)
+bbb.role(:second)
+bbb.delete(:left)
+bbb.delete(:role)
+
+bbb.role(:fourth)
+bbb.role(:five)
+bbb.role({ remove: :last })
+
+bbb.actor({ the_circle: :buttons })
+bbb.actor({ the_circle: :dummy })
+bbb.actor({ the_circle: :menu })
+
+bbb.actor({ remove: { the_circle: :dummy } })
+
+puts "1 ===> #{bbb.role}"
+puts "2 ===> #{bbb.actor}"
+puts "3 ===> #{ccc.role}"

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

@@ -10,7 +10,7 @@
 #            red: 0, green: 0, blue: 0, alpha: 1
 #          })
 #
-# Atome.new(animation: { renderers: [:browser], id: :the_animation1, type: :animation, attach: [],attached: []})
+# Atome.new(animation: { renderers: [:browser], id: :the_animation1, type: :animation, attach: [],fasten: []})
 # aa = animation({
 #                  targets: %i[my_box the_circle],
 #                  begin: {

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

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
-
 a = application({
                   id: :arp,
                   margin: 3,
                   # circle: { id: :test, color: :red },
-                  menu: { width: 220, height: 33, depth: 333, color: :black },
+                  # menu: { width: 220, height: 33, depth: 333, color: :black },
                 })
 
 page1_code = lambda do |back|
@@ -37,26 +36,26 @@ page1 = {
 color({ id: :titi, red: 1 })
 page2 = { id: :page2,
           color: :white,
-          # apply: :titi,
+          menu: false,
           run: verif,
-          # drag: true,
           box: { id: :mod_1, left: 333, top: 123, touch: { down: true, code: page1_code } }
 
 }
 
-page3 = { id: :page3,
-          color: :red,
-          # run: verif,
-          # box: { id: :mod_1,left: 333, touch: {tap: :down, code: page1_code} }
-}
+
 
 page0 = { id: :page0,
           color: :purple,
 
 }
+a.page(page0)
 a.page(page1)
 a.page(page2)
-a.page(page3)
+a.page({ id: :page3,
+         color: :red,
+         # run: verif,
+         # box: { id: :mod_1,left: 333, touch: {tap: :down, code: page1_code} }
+       })
 # wait 1 do
 #   a.page(page2)
 #   wait 1 do
@@ -118,3 +117,5 @@ a.page(page3)
 a.show(:page1)
 #   # alert :kool
 # end
+
+