atome 0.5.4.1.9 → 0.5.5.6.4

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

@@ -0,0 +1,20 @@
+#  frozen_string_literal: true
+
+
+# here is how callbock is used with atome
+test_box = box({left: -20})
+
+test_box.blur(9) do |params_back|
+  puts "here is the callback  : #{params_back}"
+end
+# per example it's possible to set back params like this
+test_box.callback({ blur: 'I am the callback content!!' })
+# now we call the callback for blur
+test_box.call(:blur)
+
+circle({id: :the_c})
+# here is a callback with event params
+test_box.drag(true) do |event|
+  grab(:the_c).left(150+event[:pageX].to_i)
+end
+

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# assign a class to atom object in the webview
+
+t=text('touch the box')
+b=box({ left: 12, id: :the_first_box })
+b.category(:matrix)
+b.touch(true) do
+  b.remove({ category: :matrix})
+  t.data= " category is : #{b.category} + look in the browser console"
+end
+t.data= " category is : #{b.category} + look in the browser console"

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+# here is how to clear the content of an atome
+b=box
+c=circle
+b.left(0)
+c.left(222)
+wait 2 do
+  # Important : please note that the view is also an atome, this this a system atome that can't be deleted,
+  # There are a few system atomes created at init time
+  # Here are the list of the system atomes created at system startup:
+  #  we can clear it's content using .clear(true) its the same action as if I have done : b.delete(true) and c.delete(true)
+  grab(:view).clear(true)
+end
+
+
+# here are the list of system atomes created at system startup :
+
+
+#Atome.new(
+#   { renderers: [], id: :eDen, type: :element, tag: { system: true }, attach: [], attached: [] }
+# )
+# Atome.new(
+#   { renderers: [], id: :user_view, type: :element, tag: { system: true },
+# 	attach: [:eDen], attached: [] }
+# )
+#
+# # color creation
+# Atome.new(
+#   { renderers: default_render, id: :view_color, type: :color, tag: ({ system: true, persistent: true }),
+# 	red: 0.15, green: 0.15, blue: 0.15, alpha: 1, top: 12, left: 12, diffusion: :linear, attach: [], attached: [] }
+# )
+#
+# Atome.new(
+#   { renderers: default_render, id: :shape_color, type: :color, tag: ({ system: true, persistent: true }),
+# 	red: 0.4, green: 0.4, blue: 0.4, alpha: 1, attach: [], attached: [] }
+# )
+#
+# Atome.new(
+#   { renderers: default_render, id: :box_color, type: :color, tag: ({ system: true, persistent: true }),
+# 	red: 0.5, green: 0.5, blue: 0.5, alpha: 1, attach: [], attached: [] }
+# )
+#
+# Atome.new(
+#   { renderers: default_render, id: :invisible_color, type: :color, tag: ({ system: true, persistent: true }),
+# 	red: 0, green: 0, blue: 0, alpha: 1, attach: [], attached: [] }
+# )
+#
+# Atome.new(
+#   { renderers: default_render, id: :text_color, type: :color, tag: ({ system: true, persistent: true }),
+# 	red: 0.9, green: 0.9, blue: 0.9, alpha: 1, attach: [], attached: [] }
+# )
+#
+# Atome.new(
+#   { renderers: default_render, id: :circle_color, type: :color, tag: ({ system: true, persistent: true }),
+# 	red: 0.6, green: 0.6, blue: 0.6, alpha: 1, attach: [], attached: [] }
+# )
+#
+# # system object creation
+# # the black_matter is used to store un materialized atomes
+# Atome.new(
+#   { renderers: default_render, id: :black_matter, type: :shape, attach: [:user_view],apply: [],
+# 	left: 0, right: 0, top: 0, bottom: 0, width: 0, height: 0, overflow: :hidden, tag: { system: true }, attached: []
+#   })
+#
+# # view port
+# Atome.new(
+#   { renderers: default_render, id: :view, type: :shape, attach: [:user_view], apply: [:view_color],
+# 	tag: { system: true },
+# 	attached: [], left: 0, right: 0, top: 0, bottom: 0, width: :auto, height: :auto, overflow: :auto,
+#   }
+#
+# )
+#
+# # unreal port, hold system object and tools
+# Atome.new(
+#   { renderers: default_render, id: :intuition, type: :shape, attach: [:user_view], tag: { system: true },
+# 	left: 0, top: 0, width: 0, height: 0, overflow: :visible, attached: [],apply: []
+#   }
+# )
+#
+# machine_id = :dummy_machine
+# # attention we must used two separate pass to avoid the password to be encode twice
+# machine_password = { read: {atome: :star_wars},write: {atome: :star_wars} }
+# user_password = { read: {atome: :star_wars},write: {atome: :star_wars} }
+#
+# machine({ id: machine_id, password: machine_password, name: :macAir, data: { date: '10090717' }, tag: { system: true } })
+#
+# human({ id: :anonymous, login: true, password: user_password, data: { birthday: '10/05/1996' }, tag: { system: true } })
+#
+# # default_user.set_current_user(:anonymous)
+# Universe.current_machine = machine_id
+# # the constant A is used to access alla atomes methods
+# A = Atome.new(
+#   { renderers: default_render, id: :atome, type: :element, tag: { system: true }, attach: [], attached: [] }
+# )

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

@@ -0,0 +1,177 @@
+# # frozen_string_literal: true
+#
+# # TODO : clones alteration must be bidirectional, to do so :
+# # 1 - we may create an atome type 'clone' then add a ' pre_render_clones option' when rendering clones property
+# # 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, id: :the_box })
+#
+# b.clones([{ left: 300, top: 300, color: :blue, entangled: [:width, :attached, :height] },
+#           { left: 600, top: 366, color: :green, entangled: [:left, :height] }])
+#
+# wait 1 do
+#   b.width(190)
+# end
+#
+# wait 2 do
+#   b.height(180)
+# end
+#
+# wait 3 do
+#   b.left(180)
+# end
+#
+# grab(:the_box_clone_0).smooth(33)
+# #
+# grab(:the_box_clone_1).rotate(33)
+#
+# wait 5 do
+#   b.clones.each do |clone_found|
+#     grab(clone_found[:id]).delete(true)
+#   end
+# end
+#
+
+class Atome
+  class << self
+    def monitoring(atomes_to_monitor, particles_to_monitor, &bloc)
+      atomes_to_monitor.each do |atome_to_monitor|
+        particles_to_monitor.each do |monitored_particle|
+          # Stockage de la méthode originale
+          original_method = atome_to_monitor.method(monitored_particle)
+
+          # Redéfinition de la méthode
+          atome_to_monitor.define_singleton_method(monitored_particle) do |*args, &proc|
+
+            # Bloc de surveillance avant l'appel de la méthode originale
+            value_before = atome_to_monitor.instance_variable_get("@#{monitored_particle}")
+            # bloc.call({ original: value_before, altered: args, particle: monitored_particle }) if bloc.is_a?(Proc)
+            # value_before=previous_value.dup
+            if args.empty?
+              args = nil
+            else
+              if monitored_particle == :touch
+                instance_variable_set("@#{monitored_particle}", { tap: args[0] })
+                instance_variable_set("@#{monitored_particle}_code", { touch: proc })
+
+                args = { tap: args[0] }
+              else
+                instance_variable_set("@#{monitored_particle}", args[0])
+              end
+              # instance_variable_set("@#{monitored_particle}",args[0])
+              args = args[0]
+            end
+            instance_exec({ original: value_before, altered: args, particle: monitored_particle }, &bloc) if bloc.is_a?(Proc)
+            original_method.call(*args)
+          end
+        end
+      end
+    end
+  end
+end
+
+c = circle({ id: :the_circle, left: 12, top: 0, color: :orange, drag: { move: true, inertia: true, lock: :start } })
+b = box({ top: 123 })
+
+t = text({ data: :hello, left: 300 })
+
+t.touch(true) do
+  alert "#{b.touch} , #{b.touch_code}"
+  b.touch_code[:touch].call
+end
+col = color({ id: :col1, red: 1, blue: 1 })
+# #######################
+atomes_monitored = [c, b]
+# particles_monitored=[:left, :width, :touch, :apply]
+particles_monitored=[:left, :width,  :apply]
+# particles_monitored = [:touch]
+Atome.monitoring(atomes_monitored, particles_monitored) do |monitor_infos|
+  puts "1 ==> #{@id} : #{monitor_infos[:particle]},#{monitor_infos[:altered]}"
+
+  atomes_monitored.each do |atome_to_update|
+    # we exclude the current  changing atome to avoid infinite loop
+    unless atome_to_update == self || (monitor_infos[:original] == monitor_infos[:altered]) || !monitor_infos[:altered]
+      puts "2 ==> #{atome_to_update.id} : #{monitor_infos[:particle]},#{monitor_infos[:altered]}"
+      atome_to_update.send(monitor_infos[:particle], monitor_infos[:altered])
+    end
+
+  end
+end
+# ####################
+b.resize(true)
+c.resize(true) do |l|
+
+  puts c.instance_variable_get("@resize_code")
+end
+ccc = color(:red)
+wait 1 do
+  # b.left(133)
+  b.touch(true) do
+    alert "b width is #{b.width}"
+  end
+  # alert "touch contain : #{b.instance_variable_get("@touch")}"
+  # alert "touch code contain :#{b.instance_variable_get("@touch_code")}"
+
+  c.left(133)
+  wait 1 do
+    # c.color(:red)
+    # c.apply([ccc.id])
+    b.width(155)
+  end
+end
+
+
+# TODO : make multi parents works
+# TODO : make it works for event like touch , also attach and attached
+# wait 2 do
+#   col = color({ id: :col1, red: 1, blue: 1 })
+#   Atome.monitoring([col], [:red, :blue], [:variable1, :variable2])
+#
+#   c.apply([:col1])
+#   wait 2 do
+#     col.red(0)
+#     col.red
+#     c.apply([:col1])
+#   end
+# end
+
+
+
+############## add class solution
+the_b=box({color: :green})
+
+the_b.resize(true) do
+  puts :j
+end
+class HTML
+
+  def id(id)
+    @element[:classList].add(id.to_s)
+    attr('id', id)
+    self
+  end
+  def add_class(val)
+    @element[:classList].add(val.to_s)
+    # @element.setAttribute('id', val)
+  end
+
+  # def force_top(id,value)
+  #   element=JS.global[:document].getElementById(id.to_s)
+  #   element[:style][:top] ='33px'
+  # end
+end
+
+new({ particle: :add_class }) do |params|
+  html.add_class(params)
+end
+#
+# new({ particle: :force_top }) do |params|
+#   html.force_top(params)
+# end
+
+b = box({ id: :toto })
+bb = box({ id: :toto, left: 333 })
+bb.add_class(:toto)
+b.add_class(:toto)
+# bb.force_top(:toto,3)

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+new({ particle: :run }) do |params, code|
+  code_found = @code_code[:code]
+  instance_exec(params, &code_found) if code_found.is_a?(Proc)
+end
+a = box
+a.code(:hello) do
+  circle({ left: 333 })
+end
+wait 1 do
+  a.run(:hello)
+end
+

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# frozen_string_literal: true
+
+# puts 'type you problematic code here!'
+col=color({green: 1, id: :the_col})
+
+b=box({top: 3})
+t=text(data: :red, left: 0, top: 123)
+t1=text(data: :green, left: 100, top: 123)
+t2=text(data: :blue, left: 200, top: 123)
+t3=text(data: :yellow, left: 300, top: 123)
+t4=text(data: :orange, left: 400, top: 123)
+t5=text(data: :cyan, left: 500, top: 123)
+
+item_to_batch=[t.id,t1.id,t2.id, t3.id, t4.id, t5.id]
+the_group= group({ collect: item_to_batch })
+the_group.apply([:the_col])
+t.touch(true) do
+  b.color({id: :red, red: 1 })
+  # puts "number of atomes : #{Universe.atomes.length}"
+end
+t1.touch(true) do
+  b.color({id: :green, green: 1 })
+  # puts "number of atomes : #{Universe.atomes.length}"
+end
+t2.touch(true) do
+  b.color({id: :blue, blue: 1 })
+  # puts "number of atomes : #{Universe.atomes.length}"
+end
+t3.touch(true) do
+  b.color({id: :yellow,  red: 1, green: 1 })
+  # puts "number of atomes : #{Universe.atomes.length}"
+end
+t4.touch(true) do
+  b.color({id: :orange,  red: 1, green: 0.5 })
+  # puts "number of atomes : #{Universe.atomes.length}"
+end
+t5.touch(true) do
+  b.color({id: :cyan,  blue: 1, green: 1 })
+  # puts "number of atomes : #{Universe.atomes.length}"
+end
+
+t=text({data: "dynamic color propagation, touch me to propagate"})
+t.apply(:the_col)
+c=circle({id: :the_circle, top: 260})
+c.apply([:the_col])
+b.apply([:the_col])
+
+t.touch(true) do
+  col.red(1)
+end
+
+

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

@@ -0,0 +1,163 @@
+#  frozen_string_literal: true
+
+b = box({ id: :the_html, color: :orange, overflow: :auto, width: :auto, height: :auto, left: 100, right: 100, top: 100, bottom: 100 })
+html_desc = <<STR
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>Une petite page HTML</title>
+        <meta charset="utf-8" />
+    </head>
+    <body>
+        <h1 id='title' style='color: yellowgreen'>Un titre de niveau 1</h1>
+
+        <p>
+            Un premier petit paragraphe.
+        </p>
+
+        <h2>Un titre de niveau 2</h2>
+
+        <p>
+            Un autre paragraphe contenant un lien pour aller
+            sur le site <a href="http://koor.fr">KooR.fr</a>.
+        </p>
+    </body>
+</html>
+STR
+
+b.hypertext(html_desc)
+
+def markup_analysis(markup) end
+
+def convert(params)
+  case
+  when params.keys.include?(:atome)
+
+    # Atome.new({type})
+    puts params[:atome]
+  else
+    # ...
+  end
+end
+
+b.hyperedit(:title) do |tag_desc|
+  convert({ atome: tag_desc })
+end
+
+# Bien sûr ! Voici une liste des principaux types de balises (tags) HTML. Cependant, notez qu'avec l'évolution du web et les différentes versions de HTML, il peut y avoir de légères variations. Cette liste est basée sur la spécification HTML5 :
+#
+# 1. **Métadonnées**:
+#    - `<!DOCTYPE>`
+#    - `<head>`
+#    - `<meta>`
+#    - `<base>`
+#    - `<link>`
+#    - `<style>`
+#    - `<title>`
+#    - `<script>`
+#    - `<noscript>`
+#
+# 2. **Structure du document**:
+#    - `<html>`
+#    - `<body>`
+#    - `<header>`
+#    - `<footer>`
+#    - `<nav>`
+#    - `<article>`
+#    - `<section>`
+#    - `<aside>`
+#    - `<h1>`, `<h2>`, `<h3>`, `<h4>`, `<h5>`, `<h6>`
+#
+# 3. **Contenu du texte**:
+#    - `<p>`
+#    - `<hr>`
+#    - `<pre>`
+#    - `<blockquote>`
+#    - `<ol>`
+#    - `<ul>`
+#    - `<li>`
+#    - `<dl>`
+#    - `<dt>`
+#    - `<dd>`
+#    - `<figure>`
+#    - `<figcaption>`
+#    - `<div>`
+#
+# 4. **Contenu en ligne**:
+#    - `<a>`
+#    - `<em>`
+#    - `<strong>`
+#    - `<small>`
+#    - `<s>`
+#    - `<cite>`
+#    - `<q>`
+#    - `<dfn>`
+#    - `<abbr>`
+#    - `<data>`
+#    - `<time>`
+#    - `<code>`
+#    - `<var>`
+#    - `<samp>`
+#    - `<kbd>`
+#    - `<sub>`
+#    - `<sup>`
+#    - `<i>`
+#    - `<b>`
+#    - `<u>`
+#    - `<mark>`
+#    - `<ruby>`
+#    - `<rt>`
+#    - `<rp>`
+#    - `<bdi>`
+#    - `<bdo>`
+#    - `<span>`
+#    - `<br>`
+#    - `<wbr>`
+#
+# 5. **Contenu intégré**:
+#    - `<img>`
+#    - `<iframe>`
+#    - `<embed>`
+#    - `<object>`
+#    - `<param>`
+#    - `<video>`
+#    - `<audio>`
+#    - `<source>`
+#    - `<track>`
+#    - `<canvas>`
+#    - `<map>`
+#    - `<area>`
+#    - `<svg>`
+#    - `<math>`
+#
+# 6. **Données du formulaire**:
+#    - `<form>`
+#    - `<input>`
+#    - `<textarea>`
+#    - `<button>`
+#    - `<select>`
+#    - `<optgroup>`
+#    - `<option>`
+#    - `<label>`
+#    - `<fieldset>`
+#    - `<legend>`
+#    - `<datalist>`
+#    - `<output>`
+#    - `<progress>`
+#    - `<meter>`
+#
+# 7. **Éléments interactifs**:
+#    - `<details>`
+#    - `<summary>`
+#    - `<command>`
+#    - `<menu>`
+#
+# 8. **Éléments d'écriture**:
+#    - `<script>`
+#    - `<noscript>`
+#    - `<template>`
+#    - `<canvas>`
+#
+# 9. **D'autres éléments** (comme les éléments dépréciés ou obsolètes de versions antérieures de HTML) peuvent également être trouvés dans le wild web, mais leur utilisation n'est pas recommandée dans les nouveaux projets.
+#
+# Cette liste n'est pas exhaustive et certaines balises pourraient être ajoutées ou modifiées avec de futures versions de HTML. Toujours se référer à la documentation officielle ou à des ressources fiables pour une liste complète à jour.

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+b = box
+c = circle
+t = text('touch me')
+
+b.copy([c.id, b.id, t.id])
+b.copy(b.id)
+
+wait 1 do
+  c.paste([0, 2])
+  wait 1 do
+    t.paste(0)
+  end
+
+end
+
+t.touch(true) do
+  copies = t.paste(0)
+  copies.each do |atome_paste|
+    wait 1 do
+      grab(atome_paste).color(:red)
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+new({ particle: :copy }) do |items_id|
+  # alert items_id
+  unless items_id.instance_of? Array
+    items_id = [items_id]
+  end
+  grab(:copy).collect << items_id
+  # new_copy_group=group({ collect: items_id })
+  # @copy << items_id
+  # @copy
+  # items_id
+  grab(:copy).collect
+end
+Atome.new({ renderers: [:html], id: :copy, collect: [], type: :group, tag: { system: true } })
+
+new({ read: :copy })
+
+new({ particle: :paste }) do |params|
+  all_copies = grab(:copy).collect
+  if params == true
+    copies_found = all_copies.last
+  elsif params.instance_of? Integer
+    copies_found = all_copies[params.to_i]
+  elsif params.instance_of? Array
+    copies_found = [all_copies[params[0]][params[1]]]
+  end
+
+  copies_found.each do |copy_found|
+    if grab(copy_found)
+      pasted_atome = grab(copy_found).duplicate({ left: 333 })
+      pasted_atome.attach(@id)
+    end
+  end
+  copies_found
+end
+
+b = box
+c = circle
+t = text(:hello)
+
+# b.copy([c.id, b.id])
+# b.copy(b.id)
+
+# test below
+# b.copy(b.id)
+# b.copy(c.id)
+
+# works below
+b.copy([c.id, b.id, t.id])
+b.copy(b.id)
+
+
+# crash below
+# b.copy([b.id, t.id])
+# b.copy(c.id)
+
+# ##########
+
+# wait 1 do
+  b.paste([0,0])
+# end
+
+b.touch(true) do
+  t.paste([0,1])
+end
+
+