atome 0.5.2.8 → 0.5.3.2

data/vendor/assets/src/medias/rubies/examples/_2_solve.rb

@@ -12,47 +12,61 @@ end
 
 c.run('it works')
 
-# object in object
+######  SOLVED ##### : object in object
 
-a = box({ width: 333, height: 333, id: :the_boxy })
-a.color(:red)
-b = a.box({ width: 33, height: 33, id: :the_box, drag: true })
-b.color(:black)
+# a = box({ width: 333, height: 333, id: :the_boxy })
+# a.color(:red)
+# b = a.box({ width: 33, height: 33, id: :the_box, drag: true })
+# b.color(:black)
+#
+# # color doesn't work
+# circle({ id: :circle_123, color: :cyan, left: 233 })
 
-# color doesn't work
-circle({ id: :circle_123, color: :cyan, left: 233 })
 
+######  SOLVED ##### : big performance problem plus params as left is not interpreted
 
-# big performance problem plus params as left is not interpreted
+# i = 0
+# while i < 16
+#   b = box({ width: 33, height: 33 })
+#   b.color(:red)
+#   b.left((33 + 10) * i)
+#   i += 1
+#   # b.drag(true)
+# end
 
-i = 0
-while i < 16
-  b = box({ width: 33, height: 33 })
-  b.parents([:the_grid])
-  b.color(:red)
-  b.left((33 + 10) * i)
-  i += 1
-  # b.drag(true)
-end
 
+######  SOLVED ##### : .color (return the color itself instead of the box ) and .red return itself too so it's impossible to set green and blue
+# another problem : when setting .red it reset the whole color object and remove green an blue components
+# box({id: :mybox})
+# grab(:my_box).smooth(6).color(:black).red(0.6).green(0.6).blue(0.6)
 
-# .color (return the color itself instead of the box ) and .red retrun itself too so it's impossible to set green and blue
-# another problem : when steeing .red it reset the whole color object and remove green an blue components
-box({id: :mybox})
-grab(:my_box).smooth(6).color(:black).red(0.6).green(0.6).blue(0.6)
 
 # color can't be changed easily
 
 b=box
 b.color.red(1)
 
-# box in box doesn't work( incorrect node tree error)
-b=box({id: :mybox, width: 666, height: 555})
+# ######  SOLVED ##### : box in box doesn't work( incorrect node tree error)
+# b=box({id: :mybox, width: 666, height: 555})
+#
+# b.box()
+
+# ######  SOLVED ##### atome i, atome using preset doesn't work
+#
+# b=box
+# c=b.box
+# c.left(200)
+
+
+# Children doesn't work
+box({ id: :the_box })
+circle({ top: 300, id: :circle098 })
 
-b.box()
+t = text({ data: :hello })
+t.children[:the_box, :circle098]
 
-# atome i, atome using preset doesn't work
 
+# if id change then we can't add color
 b=box
-c=b.box
-c.left(200)
+b.id(:new_id)
+b.color(:blue)

data/vendor/assets/src/medias/rubies/examples/_attach.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+
+# removed because it has conflict with children / parents
+# # TODO : debug the attach method it color the view by default
+# # box({id: :my_box})
+# # c=color(:red)
+# # grab(:view).color(:black)
+# # c.attach([:my_box])
+#
+# box({id: :my_box})
+# color({red: 1, blue: 1, attach: [:my_box]})

data/vendor/assets/src/medias/rubies/examples/_audio.rb

@@ -1,6 +1,61 @@
 # frozen_string_literal: true
 
-box({id: :mybox})
+generator = Genesis.generator
+
+generator.build_atome(:audio) do |p|
+  puts p
+
+end
+
+generator.build_render(:browser_audio) do |_value, _user_proc|
+  @browser_type = :div
+  id_found = @atome[:id]
+  DOM do
+    audio({ id: id_found, autoplay: false, loop: false, muted: false }).atome
+  end.append_to(BrowserHelper.browser_document[:user_view])
+  @browser_object = BrowserHelper.browser_document[id_found]
+
+
+  # `
+  # var helloWorld = new Wad({
+  #     source: './medias/audios/Binrpilot.mp3',
+  #
+  #     // add a key for each sprite
+  #     sprite: {
+  #         hello : [0, .4], // the start and end time, in seconds
+  #         world : [.4,1]
+  #     }
+  # });
+  # `
+
+
+
+end
+
+generator.build_sanitizer(:audio) do |params|
+  parent_found = found_parents_and_renderers[:parent]
+  render_found = found_parents_and_renderers[:renderers]
+  default_params = { renderers: render_found, id: "audio_#{Universe.atomes.length}", type: :audio,
+                     parents: parent_found }
+  default_params.merge!(params)
+end
+
+module BrowserHelper
+  def self.browser_path_audio(value, browser_object, _atome)
+    browser_object[:src] = value
+  end
+
+
+end
+
+box({ id: :mybox })
+
+my_audio = audio({ path: 'medias/audios/Binrpilot.mp3', id: :audio3 }) do |params|
+  puts "3 - audio callback here #{params}, id is : #{id}"
+end
+
+# my_audio.clips[{begin: 4, end: 6}]
+alert Universe.atome_list
 
 
 # `
@@ -86,33 +141,33 @@ box({id: :mybox})
 # `
 #
 #
-#
-`
-const el = document.getElementById("mybox")
-function modifyText(){
- var audio = new Audio('medias/audios/snare.wav');
-audio.play(2);
-}
-el.addEventListener("mousedown", modifyText, false);
-`
-b=box({left: 160})
-b2=box({left: 333})
-b.touch(:down) do
-  `
-var audio = new Audio('medias/audios/Binrpilot.mp3');
-audio.currentTime=12
-audio.play(2);
-console.log('ok')
-`
-end
-
-
-b2.touch(:down) do
+#########################################
+# `
+# const el = document.getElementById("mybox")
+# function modifyText(){
+#  var audio = new Audio('medias/audios/snare.wav');
+# audio.play(2);
+# }
+# el.addEventListener("mousedown", modifyText, false);
+# `
+# b=box({left: 160})
+# b2=box({left: 333})
+# b.touch(:down) do
 #   `
-#   let bell= new Audio('medias/audios/snare.wav');
-#
+# var audio = new Audio('medias/audios/Binrpilot.mp3');
+# audio.currentTime=12
+# audio.play(2);
+# console.log('ok')
 # `
-end
+# end
+#########################################
+
+# b2.touch(:down) do
+# #   `
+# #   let bell= new Audio('medias/audios/snare.wav');
+# #
+# # `
+# end
 # generator = Genesis.generator
 
 # b.touch(:double) do
@@ -164,8 +219,6 @@ end
 # `
 # end
 
-
-
 # `
 # //let saw = new Wad({source : 'sawtooth'});
 # let saw = new Wad({

data/vendor/assets/src/medias/rubies/examples/_dataset.rb

@@ -1,60 +1,50 @@
 # # frozen_string_literal: true
-
-# generator = Genesis.generator
-# generator.build_atome(:data_set)
-# generator.build_particle(:assign) do |cell_nb,&proc |
-#     # current_cell = grab("#{@matrix_id}_#{cell_nb}")
-#     if proc
-#       # @matrix_dataset[cell_nb] << proc
-#       # current_cell.instance_exec(&proc) if proc.is_a? Proc
-#     else
-#       # @matrix_dataset[cell_nb]
-#     end
-# end
-# class Atome
-#   def data_set(params = {}, &bloc)
-#     atome_type = :data_set
-#     generated_render = params[:renderers] || []
-#     generated_id = params[:id] || "#{atome_type}_#{Universe.atomes.length}"
-#     generated_parents = params[:parents] || [id.value]
-#     params = atome_common(atome_type, generated_id, generated_render, generated_parents, params)
-#     Atome.new({ atome_type => params }, &bloc)
-#   end
-# end
-#
-#
-# # create_atome(:data_set)
 #
-# a = data_set({})
-# puts a
+# tt = text({ data: :hello, id: :the_text, drag: true })
 #
-# a.assign(2) do
-#   curent_cell = self
-#   curent_cell.image({ path: "./medias/images/moto.png", width: 33, height: 33})
-#   curent_cell.active(:inactive)
-#   touch(:long) do
-#     if curent_cell.active.value ==:inactive
-#       curent_cell.color(:yellow)
-#       curent_cell.active(:active)
-#     else
-#       curent_cell.color(:red)
-#       curent_cell.active(:inactive)
-#     end
-#   end
-# end
-#
-#*
-# a.assign(3) do
-#   color({ red: 0.6, green: 0.333, blue: 0.6, alpha: 1 })
-#   grab(:vie_playground_3).shadow({ blur: 12 })
-# end
-# puts  "assign : #{a.assign}"
+# box({ id: :the_box })
+# circle({ top: 300, id: :circle098 })
 
-box({id: :the_box})
-circle({top: 300, id: :circle098})
 generator = Genesis.generator
-
 generator.build_atome(:template)
+generator.build_atome(:matrix)
+
+class Atome
+  def matrix(params)
+    parent_found = found_parents_and_renderers[:parent]
+    render_found = found_parents_and_renderers[:renderers]
+    default_params = { renderers: render_found, id: "matrix_#{Universe.atomes.length}", type: :matrix,
+                       parents: parent_found }
+
+    params[:renderer] = []
+    params[:children] = []
+    params[:parents] = [:view]
+
+    template_needed = params[:template]
+    found_margin = params[:margin] ||= 9
+
+    matrix_id = params[:id] ||= "matrix_display_nb"
+    matrix_width = params[:width] ||= 333
+    matrix_height = params[:height] ||= 333
+    matrix_left = params[:left ] ||= 33
+    matrix_top = params[:top] ||= 33
+    matrix_smooth = params[:smooth] ||= 3
+    template_grab = grab(template_needed)
+    # puts "template to get #{template_needed}"
+    matrix_color = create_matrix_colors('matrix_color_back', 0.3, 0.3, 0.6, 1)
+    cell_back_color = create_matrix_colors('cell_color_back', 0.333, 0.333, 0.7, 1)
+    matrix = create_matrix({ id: matrix_id, width: matrix_width,height: matrix_height,
+                                       left: matrix_left,top: matrix_top, smooth: matrix_smooth })
+    matrix_color.attach([matrix_id])
+    cells = create_matrix_cells(matrix_id, cell_back_color, 33, { width: 33, height: 33,
+                                                                       smooth: 9, shadow: { blur: 6 } })
+    resize_matrix({ matrix: matrix, width: matrix_width, height: matrix_height, cells: cells, columns: 3, rows: 8, margin: found_margin })
+    params
+    default_params.merge!(params)
+    matrix
+  end
+end
+
 generator.build_particle(:cells)
 generator.build_particle(:rows)
 generator.build_particle(:columns)
@@ -64,13 +54,27 @@ generator.build_sanitizer(:template) do |params|
 end
 
 def resize_matrix(params)
-  matrix=params[:matrix]
+  matrix = params[:matrix]
   matrix_width = params[:width]
   matrix_height = params[:height]
-  cells=params[:cells]
-  nb_of_cols= params[:columns]
-  nb_of_rows= params[:rows]
-  margin=params[:margin]
+  cells = params[:cells]
+  nb_of_cols = params[:columns]
+  nb_of_rows = params[:rows]
+  margin = params[:margin]
+  if matrix_width.instance_of? String
+    parent_found  = grab(params[:matrix].parents.value.last)
+    parent_width=  parent_found.width.to_px
+    matrix_width = matrix_width.sub('%', '').to_i
+    new_width= (parent_width*  matrix_width)/100
+    matrix_width= new_width
+  end
+  if matrix_height.instance_of? String
+    parent_found  = grab(params[:matrix].parents.value.last)
+    parent_height=  parent_found.height.to_px
+    matrix_height = matrix_height.sub('%', '').to_i
+    new_height= (parent_height*  matrix_height)/100
+    matrix_height= new_height
+  end
   cell_width = (matrix_width / nb_of_cols) - margin
   cell_height = (matrix_height / nb_of_rows) - margin
   row = -1
@@ -89,89 +93,165 @@ end
 generator.build_particle(:display) do |params|
 
   template_needed = params[:template]
-  targeted_atomes = params[:list] ||= []
-  sort_by=params[:sort]
-
-
-  # alert "template to get #{template_needed}"
-  # alert "add this to cells #{targeted_atomes}"
-  template_grab=grab(template_needed)
-  # alert template_grab
-  matrix_back_color=create_matrix_colors('matrix_color_back',0.3,0.3,0.6,1)
-  cell_back_color=create_matrix_colors('cell_color_back',0.333,0.333,0.7,1)
-  matrix_back_id="matrix_back_display_nb"
-  matrix_back=create_matrix_back( matrix_back_id, { width: 33, smooth: 9 })
-  matrix_back_color.attach([matrix_back_id])
-
-  cells=create_matrix_cells(matrix_back_id,cell_back_color,33,{width: 33, height: 33,
-                                                               smooth: 9,shadow: { blur: 6 }})
-  resize_matrix({matrix: matrix_back, width: 333, height: 333, cells: cells, columns: 2, rows: 8, margin: 9 })
-  # We sort, clone and put the target in the matrix
-  sorted={}
-  targeted_atomes.each_with_index  do |atome_id, index|
-    atome_found=grab(atome_id)
-    clone= atome_found.clones([{left: 33}])
-    selected_id="#{matrix_back_id}_#{index}"
-    clone.parents([selected_id])
-    cell_height=grab(selected_id).height.value-9
+  targeted_atomes = params[:elements] ||= []
+  # get params
+  sort_by = params[:sort]
+  found_width = params[:width]
+  found_height = params[:height]
+  found_left = params[:left]
+  found_right = params[:right]
+  found_margin = params[:margin] ||= 9
 
-    clone.left=3
-    clone.top=3
-    clone.width(cell_height)
-    clone.height(cell_height)
-    sorted[atome_id]=atome_found.atome[sort_by]
+  matrix(params)
 
+  # matrix_back_id = params[:id] ||= "matrix_back_display_nb"
+  # template_grab = grab(template_needed)
+  #
+  # puts "template to get #{template_needed}"
+  # matrix_back_color = create_matrix_colors('matrix_color_back', 0.3, 0.3, 0.6, 1)
+  # cell_back_color = create_matrix_colors('cell_color_back', 0.333, 0.333, 0.7, 1)
+  # matrix_back = create_matrix_back(matrix_back_id, { width: 33, smooth: 9 })
+  # matrix_back_color.attach([matrix_back_id])
+  # cells = create_matrix_cells(matrix_back_id, cell_back_color, 33, { width: 33, height: 33,
+  #                                                                    smooth: 9, shadow: { blur: 6 } })
+  # resize_matrix({ matrix: matrix_back, width: 333, height: 333, cells: cells, columns: 2, rows: 8, margin: found_margin })
 
-  end
-  # alert "==> not sorted #{sorted}"
-  sorted=sorted.sort_by {|_key, value| value}.to_h
-  # alert "**> sorted #{sorted}"
-
-  selected=params[:select] ||= []
-  selected.each do |select|
-    selected_id="#{matrix_back_id}_#{select}"
-    grab(selected_id).color(:red)
-  end
+  # We sort, clone and put the target in the matrix
+  # sorted = {}
+  # targeted_atomes.each_with_index do |atome_id, index|
+  #   atome_found = grab(atome_id)
+  #   clone = atome_found.clones([{ left: 33 }])
+  #   selected_id = "#{matrix_back_id}_#{index}"
+  #   clone.parents([selected_id])
+  #   cell_height = grab(selected_id).height.value - 9
+  #
+  #   clone.left(3)
+  #   clone.top(3)
+  #   clone.width(cell_height)
+  #   clone.height(cell_height)
+  #   sorted[atome_id] = atome_found.atome[sort_by]
+  #
+  # end
+  # sorted = sorted.sort_by { |_key, value| value }.to_h
+  # selected = params[:select] ||= []
+  # selected.each do |select|
+  #   selected_id = "#{matrix_back_id}_#{select}"
+  #   grab(selected_id).color(:red)
+  # end
 end
 
-def create_matrix_colors(name,red,green,blue,alpha)
+def create_matrix_colors(name, red, green, blue, alpha)
   Atome.new({ color: { renderers: [:browser], id: name, type: :color, parents: [], children: [],
-                       red: red, green: green, blue: blue, alpha: alpha  } })
+                       red: red, green: green, blue: blue, alpha: alpha } })
 end
 
-def create_matrix_back( id, style)
+def create_matrix( style)
   matrix = Atome.new(
-    shape: { type: :shape, renderers: [:browser], id: id, parents: [:view],width: 333, height: 333,left: 333,
-             overflow: :hidden,children: [] }
+    shape: { type: :shape, renderers: [:browser], id: style[:id], parents: [:view], width: 333, height: 333, left: 33,top: 33,
+             overflow: :hidden, children: [] }
   )
   matrix.style(style)
   matrix
 end
 
-
-def create_matrix_cells(id,cell_back_color, number_of_cells, style)
-  counter=0
-  cells=[]
+def create_matrix_cells(id, cell_back_color, number_of_cells, style)
+  counter = 0
+  cells = []
   while counter < number_of_cells
-    id_generated=id + "_#{counter}"
+    id_generated = id + "_#{counter}"
     cells << a = Atome.new(
       shape: { type: :shape, renderers: [:browser], id: id_generated, parents: [id],
                children: [:cell_color]
 
-               }
+      }
     )
     cell_back_color.attach([id_generated])
     a.style(style)
     counter += 1
   end
+
   cells
 end
 
+# template({ id: :child_in_table, code: [], cells: 16, columns: 4, rows: 4 })
+# the_view = grab(:view)
+#
+# tt.display(template: :child_in_table, sort: :id, elements: [:the_box,:the_text , :circle098], select: [1, 3, 7],
+#                  id: :my_matrix, left: 33, top: 63, width: 633, height: 333, margin: 9,
+#                  background: {color: :red, smooth: 3}, cells: {color: :orange, smooth: 9})
+#
+
+# matrix(template: :child_in_table, sort: :id, elements: [:the_box, :circle098], select: [1, 3, 7],
+#            id: :my_matrix, left: 33, top: 63, width: 633, height: 333, margin: 9,
+#            background: {color: :red, smooth: 3}, cells: {color: :orange, smooth: 9})
+# class Atome
+#   def matrix(params)
+#     alert params
+#   end
+# end
+m=matrix({width: '100%', height: '100%', left: 0, top: 0,
+          smooth: 12,id: :the_big_amazing_matrix})
+
+class Atome
+  def row(nb)
+    # alert self
+
+  end
+end
+# alert m
+# m.cell(3).color(:red)
+# alert m.cell(3)
+puts m.row(3)
+
+########### table Algo
+# Define the table as an array
+table = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34]
 
+# Define the number of rows and columns in the table
+num_rows = 5
+num_columns = 7
 
-template({ id: :child_in_table, code: [], cells: 16, columns: 4, rows: 4 })
-the_view = grab(:view)
-the_view.display(template: :child_in_table,sort: :id, list: [:the_box,:circle098], left: 33, top: 63, width: 333, height: 333)
+# Define a method to retrieve the cells in a specified row
+def get_row(table, num_columns, row_index)
+  # Calculate the start and end indices for the row
+  start_index = row_index * num_columns
+  end_index = start_index + num_columns - 1
+
+  # Get all the cells in the row using array slicing
+  row = table[start_index..end_index]
+
+  # Iterate over the cells in the row and print their values
+  row.each do |cell|
+    puts cell
+  end
+end
+
+# Define a method to retrieve the cells in a specified column
+def get_column(table, num_rows, num_columns, column_index)
+  # Initialize an array to hold the cells in the column
+  column = []
+
+  # Iterate over the rows in the table
+  num_rows.times do |row_index|
+    # Calculate the index of the cell in the column
+    cell_index = row_index * num_columns + column_index
+
+    # Get the cell at the calculated index
+    cell = table[cell_index]
+
+    # Add the cell to the column array
+    column << cell
+  end
+
+  # Iterate over the cells in the column and print their values
+  column.each do |cell|
+    puts cell
+  end
+end
 
-  the_view.display({ select: [1, 3, 7], id: :child_in_table })
+# Test the methods
+puts "Third row:"
+get_row(table, num_columns, 2)
 
+puts "\nSecond column:"
+get_column(table, num_rows, num_columns, 1)

data/vendor/assets/src/medias/rubies/examples/clone.rb

@@ -5,7 +5,7 @@
 # 2 - this pre_render_clones option, will catch alterations and throw it the the original atome
 # 3 - we also add a new particle call mirror that holds the particle's list that will reverse intrication
 
-b = box({ color: :red, smooth: 6 })
+b = box({ color: :red, smooth: 6, id: :the_box })
 
 b.clones([{ left: 300, top: 300, color: :blue, intricate: [:width, :attached,:height ] },
           {left: 600, top: 366, color: :green , intricate: [:left, :height ]}])
@@ -22,9 +22,9 @@ wait 3 do
   b.left(180)
 end
 
-grab(:box_4_clone_1).smooth(33)
-
-grab(:box_4_clone_1).rotate(33)
+grab(:the_box_clone_0).smooth(33)
+#
+grab(:the_box_clone_1).rotate(33)
 
 
 wait 5 do

data/vendor/assets/src/medias/rubies/examples/delete.rb

@@ -2,14 +2,14 @@
 
 b = box({left: 333})
 
-b.circle({top: 66, id: :the_circle})
+b.circle({top: 66, id: :the_circle, color: :green})
 
 wait 4 do
   b.delete(true)
 end
 
 wait 3 do
-  b.attached.value.each do |attached_atome_id|
+  b.children.value.each do |attached_atome_id|
     b.delete({id: attached_atome_id})
     b.shadow({ renderers: [:browser], id: :shadow2, type: :shadow, parents: [], children: [],
                 left: 3, top: 9, blur: 3, direction: '',

data/vendor/assets/src/medias/rubies/examples/drag.rb

@@ -32,8 +32,9 @@ b.drag({ lock: :x })
 # b.drag({ remove: true })
 # b.drag({ remove: false })
 
-# b.drag({ snap: { x: 100, y: 190 } })
 
 # b.drag({ constraint: { top: 330, left: 30, bottom: 30, right: 1 } })
 b.drag({ constraint: :parent })
+b.drag({ snap: { x: 100, y: 190 } })
+
 # b.drag({ constraint: :the_boxy })