atome 0.5.7.3.6 → 0.5.7.4.2

data/lib/molecules/intuition/utilities.rb

@@ -1,10 +1,147 @@
 # frozen_string_literal: true
 
+class Atome
+  def reorder_menu
+    disposition = data[:inactive][:disposition]
+    margin = data[:inactive][:margin]
+    spacing = data[:inactive][:spacing]
+    inactive_style = data[:inactive]
+    keys_to_exclude = [:margin, :spacing, :disposition, :text]
+    inactive_style = inactive_style.reject { |key, _| keys_to_exclude.include?(key) }
+    fasten.each_with_index do |atome_f, index|
+      menu_item = grab(atome_f)
+      if disposition == :horizontal
+        menu_item.left = margin[:left] + (inactive_style[:width] + spacing) * index
+        menu_item.top = margin[:top]
+      else
+        menu_item.top = margin[:top] + (inactive_style[:height] + spacing) * index
+        menu_item.left = margin[:left]
+      end
+    end
+  end
+
+  def remove_menu_item(item_to_remove)
+    grab(item_to_remove).delete(recursive: true)
+    reorder_menu
+  end
+
+  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 })
+    actor({ button_id => :button })
+    menu_item.role(:button)
+    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)
+
+      # reorder_menu
+      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.text.each do |text_f|
+          # below we unset any active style
+          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
+            grab(text_f).set(active_state_text)
+          end
+
+        end
+        menu_item.set(active_style)
+        code&.call
+        @active_item = menu_item.id
+      end
+
+    end
+
+  end
+
+  def add_button(params)
+    params.each do |button_id, params|
+      label = params[:text]
+      code = params[:code]
+      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
   new_id = params.delete(:id) || identity_generator
-
   trigger = params.delete(:trigger)
   trigger ||= :return
   limit = params.delete(:limit)
@@ -15,8 +152,6 @@ new(molecule: :input) do |params, bloc|
   text_params ||= {}
   default_text = params.delete(:default)
   component = params.delete(:component)
-  # component ||= {}
-
   default_text ||= :input
   default_parent = if self.instance_of?(Atome)
                      id
@@ -37,44 +172,33 @@ new(molecule: :input) do |params, bloc|
       position: :absolute
     }.merge(text_params)
   )
-  # text_input.set()
   text_input.touch(:down) do
     input_back.tick(:input)
     text_input.edit(true)
   end
 
   input_back.touch(:up) do
-    if input_back.tick[:input] == 1
-      text_input.component({ selected: true })
-    end
+    text_input.component({ selected: true }) if input_back.tick[:input] == 1
   end
 
   text_input.keyboard(:down) do |native_event|
-    # text_input.component({ selected: { color: :red, text: :red } })
-
     event = Native(native_event)
     if event[:keyCode].to_s == '8' || event[:keyCode].to_s == '46'
       # always allow
     elsif event[:keyCode].to_s == '13'
       # we prevent the input
-      if trigger == :return
-        bloc.call(text_input.data)
-      end
+      bloc.call(text_input.data) if trigger == :return
       text_input.edit(false)
       event.preventDefault()
     elsif text_input.data.length > limit
       event.preventDefault()
     end
-    if trigger == :down
-      bloc.call(text_input.data)
-    end
+    bloc.call(text_input.data) if trigger == :down
   end
 
-  text_input.keyboard(:up) do |native_event|
+  text_input.keyboard(:up) do |_native_event|
     input_back.data = text_input.data
-    if trigger == :up
-      bloc.call(text_input.data)
-    end
+    bloc.call(text_input.data) if trigger == :up
   end
   params.each do |part_f, val_f|
     input_back.send(part_f, val_f)
@@ -84,13 +208,11 @@ new(molecule: :input) do |params, bloc|
 end
 
 new(molecule: :list) do |params, _bloc|
-
   styles_found = params.delete(:styles)
   element = params.delete(:element)
   listing = params.delete(:listing)
   action = params.delete(:action)
   new_id = params.delete(:id) || identity_generator
-
   styles_found ||= {
     width: 99,
     height: 33,
@@ -105,12 +227,8 @@ new(molecule: :list) do |params, _bloc|
                 top: :center,
                 color: :orange,
                 type: :text }
-  unless params[:width]
-    params[:width] = styles_found[:width]
-  end
-  unless element[:width]
-    element[:width] = styles_found[width]
-  end
+  params[:width] = styles_found[:width] unless params[:width]
+  element[:width] = styles_found[width] unless element[:width]
   margin = styles_found[:margin]
   height_found = styles_found[:height]
 
@@ -168,7 +286,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 +406,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
@@ -438,61 +484,116 @@ new(molecule: :application) do |params, &bloc|
          else
            identity_generator
          end
+
   main_app = box({ id: id_f, width: :auto, height: :auto, top: 0, bottom: 0, left: 0, right: 0, apply: :app_color,
                    category: :application })
   main_app.remove(:box_color)
   main_app.instance_variable_set('@pages', {})
-  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)
+  main_app.role(:application)
+
+  menu = 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.define_singleton_method(:menu) do
+    menu
+  end
+  main_app.define_singleton_method(:pages) do
+    @pages
+  end
+
+  main_app.define_singleton_method(:insert) do |bloc_to_add|
+    bloc_to_add.each do |page_id, params_f|
+      params_f.each do |block_id, block_content|
+        @pages[page_id][:blocks] ||= {}
+        @pages[page_id][:blocks][block_id.to_sym] = block_content
+      end
+      @blocks ||= {}
+      @blocks[page_id] = @pages[page_id][:blocks]
+    end
+
+  end
+  main_app.define_singleton_method(:extract) do |bloc_to_extract|
+    bloc_to_extract.each do |page_id, block_id|
+      @blocks[page_id].delete(block_id)
+    end
+
+  end
+
+  main_app.define_singleton_method(:blocks) do
+    @blocks
   end
+  main_app.define_singleton_method(:margin) do
+    @margin = params[:margin]
+  end
+  main_app.define_singleton_method(:spacing) do
+    @spacing = params[:spacing]
+  end
+
   main_app
 end
 
-new(molecule: :page) do |params, &bloc|
+new(molecule: :page) do |params = nil, &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 })
+  end
 end
 
 new(molecule: :show) do |page_id, &bloc|
+
   params = @pages[page_id.to_sym]
   params ||= {}
   footer = params.delete(:footer)
   header = params.delete(:header)
   left_side_bar = params.delete(:left_side_bar)
   right_side_bar = params.delete(:right_side_bar)
-  # modules = params.delete(:modules)
   basic_size = 30
-  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)
+    page_found.delete({ recursive: true }) if page_found&.category&.include?(:page)
   end
   color({ id: :page_color, red: 0.1, green: 0.1, blue: 0.1 })
-  # TODO : remove the patch below when possible
-  id_f = if params[:id]
-           params.delete(:id)
-         else
-           "#{id_f}_#{identity_generator}"
-         end
+
+  id_f = "#{id}_content"
   main_page = box({ width: :auto, depth: -1, height: :auto, id: id_f, top: 0, bottom: 0, left: 0, right: 0, apply: :page_color, category: :page })
   main_page.remove(:box_color)
 
-  main_page.set(params)
+  new_page = main_page.box({ width: '100%', height: '100%', top: 0, left: 0, id: page_id })
+
+  # now looking for associated blocks
+  blocks_found = params[:blocks]
+  @prev_bloc_height = 0
+  blocks_found&.each_with_index do |(bloc_id, bloc_content), index|
+
+    new_bloc = new_page.box({ id: bloc_id, width: '100%', height: 99, top: spacing + @prev_bloc_height, bottom: 0, left: 0, right: 0 })
+    new_bloc.set(bloc_content)
+    @prev_bloc_height = @prev_bloc_height + new_bloc.height + spacing
+  end
+
+  keys_to_exclude = [:blocks]
+  particles_to_apply = params.reject { |key, _| keys_to_exclude.include?(key) }
 
+  new_page.set(particles_to_apply)
   if footer
     new_footer = box({ left: 0, depth: -1, right: 0, width: :auto, top: :auto, bottom: 0, height: basic_size, category: :footer, id: "#{id_f}_footer" })
     new_footer.remove(:box_color)
@@ -517,7 +618,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)
@@ -531,24 +632,49 @@ new(molecule: :show) do |page_id, &bloc|
     if item_found&.category&.include?(:right_side_bar)
       main_page.width(:auto)
       main_page.left(item_found.width)
-      if footer
-        grab("#{id_f}_footer").right(basic_size)
-      end
-      if header
-        grab("#{id_f}_header").right(basic_size)
-      end
+      grab("#{id_f}_footer").right(basic_size) if footer
+      grab("#{id_f}_header").right(basic_size) if header
     end
 
     if item_found&.category&.include?(:left_side_bar)
       main_page.width(:auto)
       main_page.right(item_found.width)
-      if footer
-        grab("#{id_f}_footer").left(basic_size)
-      end
-      if header
-        grab("#{id_f}_header").left(basic_size)
-      end
+      grab("#{id_f}_footer").left(basic_size) if footer
+      grab("#{id_f}_header").left(basic_size) if header
     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_f = params.delete(:id) || identity_generator
+  main = grab(context).box({ id: id_f })
+  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) || {}
+  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/atome_opal_extensions.rb

@@ -4,7 +4,6 @@ require 'extensions/object'
 require 'extensions/js'
 require 'extensions/geolocation'
 require 'extensions/ping'
-require 'extensions/sha'
 require 'extensions/color'
 require 'native'
 require 'promise'

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

@@ -3,11 +3,6 @@
 # rgb utility
 class Atome
   def rgb_html(string)
-    #    `
-    #  col = w3color(#{string});
-    #  rgb_col=col.toRgb();
-    #  return Opal.hash(rgb_col)
-    # `
     js_code = <<-JS
   var col = w3color('#{string}');
   var rgb_col = col.toRgb();

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

@@ -2,13 +2,13 @@
 
 class Atome
   def geolocation
-    localisation = {latitude: nil, longitude: nil}
+    localisation = { latitude: nil, longitude: nil }
     $window.navigator.geolocate.then do |pos|
-      localisation[:latitude] =  pos.coords.latitude
-      localisation[:longitude] =  pos.coords.longitude
+      localisation[:latitude] = pos.coords.latitude
+      localisation[:longitude] = pos.coords.longitude
     end.rescue do |err|
-      p  err
-      localisation = nil
+      p err
+      nil
     end
   end
 end

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

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

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

@@ -4,28 +4,19 @@
 class Atome
   def ping(my_proc = false)
     instance_exec(my_proc) if my_proc.is_a?(Proc)
-#     ` var p = new Ping();
-#         p.ping('https://'+#{address}+'', function (err, data) {
-#             if (err) {
-#                return false;
-#             } else {
-#  console.log("the site "+#{address}+" is up!");
-#             }
-#         });
-# `
-    js_code = <<-JS
-var p = new Ping();
-p.ping('https://' + "#{address}" + '', function (err, data) {
-    if (err) {
-       return false;
-    } else {
-       console.log("the site " + "#{address}" + " is up!");
-    }
-});
-JS
+
+    js_code = <<~JS
+      var p = new Ping();
+      p.ping('https://' + "#{address}" + '', function (err, data) {
+          if (err) {
+             return false;
+          } else {
+             console.log("the site " + "#{address}" + " is up!");
+          }
+      });
+    JS
 
     # Exécute le code JavaScript
     JS.eval(js_code)
-
   end
 end

data/lib/renderers/html/effect.rb

@@ -28,7 +28,6 @@ new({ renderer: :html, method: :blur, type: :integer }) do |params, _user_proc|
     end
   end
 
-
 new({ renderer: :html, method: :blur, type: :integer, specific: :shadow }) do |params, _user_proc|
   if params[:affect] == :back
     html.backdropFilter(:blur, "#{params[:value]}px")
@@ -39,13 +38,3 @@ new({ renderer: :html, method: :blur, type: :integer, specific: :shadow }) do |p
    affect(affect)
 end
 
-# new({ particle: :blur, category: :effect, type: :int , specific: :shadow}) do |params|
-#   alert :cool
-#   if affect.nil?
-#     affect_to = affect
-#   else
-#     affect_to = [:self]
-#   end
-#   val= { value: params, affect: affect_to } unless params.instance_of?(Hash)
-#   val
-# end

data/lib/renderers/html/event.rb

@@ -1,13 +1,6 @@
 # frozen_string_literal: true
 
 new({ method: :drag, type: :symbol, renderer: :html }) do |params|
-  # if @drag
-  #   option = @drag[params]
-  # else
-  #   params = :remove
-  #   option = true
-  # end
-  # html.event(:drag, params, option)
 
   if params
     option = @drag[params]