atome 0.5.7.5.9 → 0.5.7.6.5

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

@@ -22,3 +22,21 @@ end
 
 
 
+
+def api_infos
+  {
+  "example": "Purpose of the example",
+  "methods_found": [
+    "box",
+    "circle"
+  ],
+  "box": {
+    "aim": "The `box` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `box`."
+  },
+  "circle": {
+    "aim": "The `circle` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `circle`."
+  }
+}
+end

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

@@ -23,3 +23,31 @@ b.touch(:tap) do
   }
 end
 
+
+def api_infos
+  {
+  "example": "Purpose of the example",
+  "methods_found": [
+    "code",
+    "data",
+    "run",
+    "touch"
+  ],
+  "code": {
+    "aim": "The `code` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `code`."
+  },
+  "data": {
+    "aim": "The `data` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `data`."
+  },
+  "run": {
+    "aim": "The `run` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `run`."
+  },
+  "touch": {
+    "aim": "Handles touch or click events to trigger specific actions.",
+    "usage": "Example: `touch(:tap) do ... end` triggers an action when tapped."
+  }
+}
+end

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

@@ -3,4 +3,4 @@ A.terminal('pwd') do |data|
   text "terminal response  :\n #{data}"
 end
 
-# alert A.inspect
+# alert A.inspect

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

@@ -1,16 +1,140 @@
 # frozen_string_literal: true
 
-
 def contact_template
-{ id: :humans, role: nil, date: { companies: [], project: {}, events: {}, last_name: nil, first_name: nil ,
-                                  emails: { home: nil }, phones: {}, address: {}, groups: [] } }
+  { id: :humans, role: nil, date: { companies: [], project: {}, events: {}, last_name: nil, first_name: nil,
+                                    emails: { home: nil }, phones: {}, address: {}, groups: [] } }
 end
 
-
-element({id: :testing, data: contact_template})
+element({ id: :testing, data: contact_template })
 # grab(:testing).data(contact_template)
 
-
 wait 2 do
   grab(:testing).data
 end
+
+def api_infos
+  {
+    "example": "Purpose of the example",
+    "methods_found": []
+  }
+end
+
+########## new tests
+
+atome_object_list = {
+  particles: Universe.particle_list.keys,
+  atomes: Universe.atome_list,
+  molecules: Universe.molecule_list,
+  preset: Universe.preset_list,
+
+}
+
+################ code to develop #######################
+A.browser("../src/medias/utils/examples")
+########################################################
+b = box
+b.touch(true) do
+  A.write({ name: './my file.txt', content: "my texte is ...." }) do |data|
+    text "file content  :\n #{data}"
+  end
+  wait 0.5 do
+    A.read('./my file.txt') do |data|
+      text "file content  :\n #{data}"
+    end
+  end
+
+  wait 2 do
+    A.terminal('pwd') do |data|
+      text "terminal response  :\n #{data}"
+      path_f = data.chomp + '/atome_server.rb'
+      text "path is : #{path_f}"
+
+    end
+  end
+
+  wait 1 do
+    A.terminal('ls') do |data|
+      text "terminal response  :\n #{data}"
+    end
+  end
+end
+
+# class EFile
+#   def self.open(*args)
+#     puts "=======> File Custom open called with arguments: #{args.inspect}"
+#     # new  # Retourne une instance de AFile
+#   end
+#
+#   def method_missing(name, *args, &block)
+#     puts "=======> File Method '#{name}' called with arguments: #{args.inspect}"
+#   end
+# end
+#
+# def send_dir_to_server(var)
+#   puts "===> Sending directory to server: #{var}"
+#   # Simule une réponse du serveur avec une liste de fichiers
+#   ['file1.txt', 'file2.rb', 'file3.md']
+# end
+#
+# class EDir
+#   def self.foreach(path)
+#     files = send_dir_to_server(path) # Appel au serveur pour récupérer la liste des fichiers
+#     files.each do |file|
+#       yield file if block_given?
+#     end
+#   end
+#
+#   def method_missing(name, *args, &block)
+#     send_dir_to_server(name)
+#   end
+# end
+#
+# #
+# # # Écriture dans un fichier
+# #
+# EFile.open(“index.rb”, “w”) do |f|
+#   f.puts "hello world"
+# end
+# #
+# # # Lister les fichiers d’un dossier
+# #
+# # dossier = “chemin_du_dossier”
+# # fichiers = Dir.entries(dossier).select { |f| File.file?(File.join(dossier, f)) }
+# #
+# # # Parcourir les fichiers d’un dossier
+#
+#
+# # EDir.foreach('./') do |f|
+# #   puts f unless EFile.directory?("./#{f}")
+# # end
+#
+#
+#
+# fichier = EFile.open("index.rb","r")
+# # contenu = fichier.read
+# # puts contenu
+# # fichier.close
+
+# ####################### works
+
+# # Appel principal avec bloc
+# b = image('waveform')
+# atomes_found = b.dig
+#
+# found_area_used(atomes_found) do |result|
+#   total_width = result[:max][:x] - result[:min][:x]
+#   total_height = result[:max][:y] - result[:min][:y]
+#   alert total_width
+#   alert total_height
+# end
+
+# b=box
+# b=image('red_planet')
+#
+#   atomes_found = b.dig
+# # alert b.dig
+# # alert b.dig.class
+#   total_width = found_area_used(atomes_found)[:max][:x] - found_area_used(atomes_found)[:min][:x]
+#   # total_height = found_area_used(atomes_found)[:max][:y] - found_area_used(atomes_found)[:min][:y]
+#   alert total_width
+

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

@@ -3,3 +3,10 @@
 t2 = text({ data: ['this is ', :super, { data: 'cool', color: :red, id: :new_one }], component: { size: 33 }, left: 120 })
 the_text = text({  data: 'hello for al the people in front of their machine', center: true, top: 120, width: 77, component: { size: 11 } })
 
+
+def api_infos
+  {
+  "example": "Purpose of the example",
+  "methods_found": []
+}
+end

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

@@ -1,3 +1,9 @@
 # frozen_string_literal
 
-text({data: :centering,align: :center, width: 180, top: 33, left: 0, position: :absolute, color: :red})
+text({data: :centering,align: :center, width: 180, top: 33, left: 0, position: :absolute, color: :red})
+def api_infos
+  {
+  "example": "Purpose of the example",
+  "methods_found": []
+}
+end

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

@@ -36,4 +36,36 @@ bb.touch(true) do
   else
     bb.color(:blue)
   end
-end
+end
+def api_infos
+  {
+  "example": "Purpose of the example",
+  "methods_found": [
+    "color",
+    "dummy",
+    "dummy2",
+    "tick",
+    "touch"
+  ],
+  "color": {
+    "aim": "Sets or modifies the color of the object.",
+    "usage": "For example, `color(:red)` changes the object's color to red."
+  },
+  "dummy": {
+    "aim": "The `dummy` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `dummy`."
+  },
+  "dummy2": {
+    "aim": "The `dummy2` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `dummy2`."
+  },
+  "tick": {
+    "aim": "The `tick` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `tick`."
+  },
+  "touch": {
+    "aim": "Handles touch or click events to trigger specific actions.",
+    "usage": "Example: `touch(:tap) do ... end` triggers an action when tapped."
+  }
+}
+end

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

@@ -0,0 +1,391 @@
+# frozen_string_literal: true
+
+new(molecule: :roller) do |params = {}|
+  roller_id = params[:id] ||= identity_generator
+  roller = box({ id: roller_id, width: 900, height: 333, color: :orange })
+  JS.eval("aRoll('#{roller_id}_roller','#{roller_id}', #{roller.width}, #{roller.height})")
+  roller
+end
+new({ molecule: :button }) do |params, bloc|
+  but = box({ smooth: 6, shadow: { alpha: 0.3 }, width: 25, height: 25, color: :red })
+  but.shadow({ alpha: 0.6, left: -3, top: -3, blur: 3, invert: true })
+  label = params.delete(:label) || 'button'
+  idf_f = params.delete(:id) || identity_generator
+  but.text({id: idf_f, data: label, component: { size: 9 }, center: true, position: :absolute })
+
+  but.instance_variable_set('@on', true)
+  but.set(params)
+
+  def code_logic(but, bloc)
+    but.instance_exec(&bloc) if bloc.is_a?(Proc)
+    if but.instance_variable_get('@on') == true
+      but.instance_variable_set('@on', false)
+    else
+      but.instance_variable_set('@on', true)
+    end
+  end
+
+  but.touch(true) do
+    code_logic(but, bloc)
+  end
+  but
+end
+
+def roll_playback_verif(val)
+  puts val
+end
+
+class Atome
+  def roller_play(idf, callback, &bloc)
+    idf = "#{idf}_roller"
+    puts "create a 'ruby_method' on the fly and make RBevalL('ruby_method(ev)')"
+    JS.eval <<~JS
+      globalThis.#{callback} = function(ev) {
+         console.log(ev);
+          console.log('------');
+      };
+    JS
+    JS.eval("document.getElementById('#{idf}').play(#{callback});")
+  end
+
+  def roller_stop(idf)
+    idf = "#{idf}_roller"
+    JS.eval("document.getElementById('#{idf}').stop();")
+  end
+
+  def roller_tempo(idf, tempo)
+    idf = "#{idf}_roller"
+    JS.eval("setTempo('#{idf}', #{tempo})")
+  end
+end
+
+roller({ id: :roller, callback: :roll_playback_verif })
+
+button({ label: :play, id: :player, top: :auto, bottom: 0 }) do
+  if @on
+    roller_play('roller', 'pianorollCallback') do |note|
+      puts 'super'
+    end
+  else
+    roller_stop('roller')
+  end
+end
+
+slider({ orientation: :vertical, range: { color: :white }, value: 55, width: 18, height: 199, attach: :intuition,
+         left: 900, top: 3, color: :red, cursor: { color: { alpha: 1, red: 0.12, green: 0.12, blue: 0.12 },
+                                                   width: 9, height: 6, smooth: 3 } }) do |value|
+  A.roller_tempo('roller', value * 3)
+end
+
+#  case "xrange":
+#         document.getElementById("proll").xrange=k.value*timebase;
+#         break;
+#     case "xoffset":
+#         document.getElementById("proll").xoffset=k.value*timebase;
+#         break;
+#     case "yrange":
+#         document.getElementById("proll").yrange=k.value;
+#         break;
+#     case "yoffset":
+#         document.getElementById("proll").yoffset=k.value;
+#         break;
+#     }
+
+# <button onclick="setTempo('proll')">set tempo</button>
+# <button onclick="play()">Play</button>
+# <button onclick="stop()">Stop</button>
+# <button onclick="changeEditMode('proll','dragmono')">Drag Mono</button>
+# <button onclick="changeEditMode('proll','dragpoly')">Drag Poly</button>
+# <button onclick="AddNote('proll')">Add Note</button>
+# <button onclick="setMarkStart('proll')">set start marker</button>
+# <button onclick="setMarkEnd('proll')">set end marker</button>
+# <button onclick="playHead('proll')">Move play head</button>
+# <button onclick="menu('proll')">menu</button>
+# <button onclick="editing('proll')">edit/select</button>
+# <button onclick="group('proll')">group</button>
+# <button onclick="notes('proll')">notes list</button>
+# <button onclick="selectAll('proll')">select all</button>
+# <button onclick="deSelectAll('proll')">de-select all</button>
+# <button onclick="deleteSelectedNotes('proll')">delete selection</button>
+# <button onclick="marker('proll')">marker</button>
+# <button onclick="removeMarker('proll')">remove marker</button>
+# <button onclick="removeAllMarkers('proll')">remove all markers</button>
+
+# JS.eval <<~JS
+#           var actx, osc, gain;
+#
+#         function init_audio() {
+#             timebase = 16;
+#             actx = new AudioContext();
+#             osc = actx.createOscillator();
+#             gain = actx.createGain();
+#             gain.gain.value = 0;
+#             osc.type = "sawtooth";
+#             osc.start();
+#             osc.connect(gain).connect(actx.destination);
+#         }
+#
+#
+#         function Callback(ev) {
+#             const currentTime = actx.currentTime;
+#             const startTime = currentTime + (ev.t - performance.now() / 1000);
+#             const endTime = currentTime + (ev.g - performance.now() / 1000);
+#             osc.detune.setValueAtTime((ev.n - 69) * 100, startTime);
+#             gain.gain.setTargetAtTime(0.5, startTime, 0.005);
+#             gain.gain.setTargetAtTime(0, endTime, 0.1);
+#         }
+#
+#         function play() {
+#             gain.connect(actx.destination);
+#             actx.resume().then(() => {
+#                 console.log('Audio context resumed');
+#             });
+#             document.getElementById("proll").play(Callback);
+#         }
+#
+#         function stop() {
+#             gain.disconnect();
+#             actx.suspend().then(() => {
+#                 console.log('Audio context suspended');
+#             });
+#             document.getElementById('proll').stop()
+#         }
+# JS
+
+#    <script>
+#         var actx, osc, gain;
+#
+#         function init_audio() {
+#             timebase = 16;
+#             actx = new AudioContext();
+#             osc = actx.createOscillator();
+#             gain = actx.createGain();
+#             gain.gain.value = 0;
+#             osc.type = "sawtooth";
+#             osc.start();
+#             osc.connect(gain).connect(actx.destination);
+#         }
+#
+#
+#         function Callback(ev) {
+#             const currentTime = actx.currentTime;
+#             const startTime = currentTime + (ev.t - performance.now() / 1000);
+#             const endTime = currentTime + (ev.g - performance.now() / 1000);
+#             osc.detune.setValueAtTime((ev.n - 69) * 100, startTime);
+#             gain.gain.setTargetAtTime(0.5, startTime, 0.005);
+#             gain.gain.setTargetAtTime(0, endTime, 0.1);
+#         }
+#
+#         function play() {
+#             gain.connect(actx.destination);
+#             actx.resume().then(() => {
+#                 console.log('Audio context resumed');
+#             });
+#             document.getElementById("proll").play(Callback);
+#         }
+#
+#         function stop() {
+#             gain.disconnect();
+#             actx.suspend().then(() => {
+#                 console.log('Audio context suspended');
+#             });
+#             document.getElementById('proll').stop()
+#         }
+#     </script>
+def api_infos
+  {
+  "example": "Purpose of the example",
+  "methods_found": [
+    "005",
+    "1",
+    "12",
+    "3",
+    "5",
+    "6",
+    "connect",
+    "createGain",
+    "createOscillator",
+    "currentTime",
+    "delete",
+    "destination",
+    "detune",
+    "disconnect",
+    "eval",
+    "g",
+    "gain",
+    "getElementById",
+    "height",
+    "instance_exec",
+    "instance_variable_get",
+    "instance_variable_set",
+    "is_a",
+    "log",
+    "n",
+    "now",
+    "resume",
+    "roller_tempo",
+    "set",
+    "shadow",
+    "start",
+    "suspend",
+    "t",
+    "text",
+    "touch",
+    "type",
+    "value",
+    "width"
+  ],
+  "005": {
+    "aim": "The `005` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `005`."
+  },
+  "1": {
+    "aim": "The `1` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `1`."
+  },
+  "12": {
+    "aim": "The `12` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `12`."
+  },
+  "3": {
+    "aim": "The `3` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `3`."
+  },
+  "5": {
+    "aim": "The `5` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `5`."
+  },
+  "6": {
+    "aim": "The `6` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `6`."
+  },
+  "connect": {
+    "aim": "The `connect` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `connect`."
+  },
+  "createGain": {
+    "aim": "The `createGain` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `createGain`."
+  },
+  "createOscillator": {
+    "aim": "The `createOscillator` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `createOscillator`."
+  },
+  "currentTime": {
+    "aim": "The `currentTime` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `currentTime`."
+  },
+  "delete": {
+    "aim": "The `delete` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `delete`."
+  },
+  "destination": {
+    "aim": "The `destination` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `destination`."
+  },
+  "detune": {
+    "aim": "The `detune` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `detune`."
+  },
+  "disconnect": {
+    "aim": "The `disconnect` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `disconnect`."
+  },
+  "eval": {
+    "aim": "The `eval` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `eval`."
+  },
+  "g": {
+    "aim": "The `g` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `g`."
+  },
+  "gain": {
+    "aim": "The `gain` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `gain`."
+  },
+  "getElementById": {
+    "aim": "The `getElementById` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `getElementById`."
+  },
+  "height": {
+    "aim": "The `height` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `height`."
+  },
+  "instance_exec": {
+    "aim": "The `instance_exec` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `instance_exec`."
+  },
+  "instance_variable_get": {
+    "aim": "The `instance_variable_get` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `instance_variable_get`."
+  },
+  "instance_variable_set": {
+    "aim": "The `instance_variable_set` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `instance_variable_set`."
+  },
+  "is_a": {
+    "aim": "The `is_a` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `is_a`."
+  },
+  "log": {
+    "aim": "The `log` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `log`."
+  },
+  "n": {
+    "aim": "The `n` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `n`."
+  },
+  "now": {
+    "aim": "The `now` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `now`."
+  },
+  "resume": {
+    "aim": "The `resume` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `resume`."
+  },
+  "roller_tempo": {
+    "aim": "The `roller_tempo` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `roller_tempo`."
+  },
+  "set": {
+    "aim": "The `set` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `set`."
+  },
+  "shadow": {
+    "aim": "The `shadow` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `shadow`."
+  },
+  "start": {
+    "aim": "The `start` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `start`."
+  },
+  "suspend": {
+    "aim": "The `suspend` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `suspend`."
+  },
+  "t": {
+    "aim": "The `t` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `t`."
+  },
+  "text": {
+    "aim": "The `text` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `text`."
+  },
+  "touch": {
+    "aim": "Handles touch or click events to trigger specific actions.",
+    "usage": "Example: `touch(:tap) do ... end` triggers an action when tapped."
+  },
+  "type": {
+    "aim": "The `type` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `type`."
+  },
+  "value": {
+    "aim": "The `value` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `value`."
+  },
+  "width": {
+    "aim": "The `width` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `width`."
+  }
+}
+end

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

@@ -7,3 +7,31 @@ b.touch(true) do
   b.width(t.to_percent(:width))
   b.left(t.to_percent(:left))
 end
+
+def api_infos
+  {
+  "example": "Purpose of the example",
+  "methods_found": [
+    "left",
+    "to_percent",
+    "touch",
+    "width"
+  ],
+  "left": {
+    "aim": "Controls the horizontal position of the object within its container.",
+    "usage": "For example, `left(100)` moves the object 100 pixels from the left edge."
+  },
+  "to_percent": {
+    "aim": "The `to_percent` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `to_percent`."
+  },
+  "touch": {
+    "aim": "Handles touch or click events to trigger specific actions.",
+    "usage": "Example: `touch(:tap) do ... end` triggers an action when tapped."
+  },
+  "width": {
+    "aim": "The `width` method's purpose is determined by its specific functionality.",
+    "usage": "Refer to Atome documentation for detailed usage of `width`."
+  }
+}
+end