atome 0.5.2.7 → 0.5.2.8

data/vendor/assets/{build → src}/medias/rubies/examples/_2_solve.rb

@@ -55,4 +55,4 @@ b.box()
 
 b=box
 c=b.box
-c.left(200)
+c.left(200)

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

@@ -0,0 +1,177 @@
+# # 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
+#
+# 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})
+generator = Genesis.generator
+
+generator.build_atome(:template)
+generator.build_particle(:cells)
+generator.build_particle(:rows)
+generator.build_particle(:columns)
+generator.build_sanitizer(:template) do |params|
+  default_params = { renderers: [], id: "template_#{Universe.atomes.length}", type: :template }
+  default_params.merge!(params)
+end
+
+def resize_matrix(params)
+  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]
+  cell_width = (matrix_width / nb_of_cols) - margin
+  cell_height = (matrix_height / nb_of_rows) - margin
+  row = -1
+  cells.each_with_index do |cell, index|
+    cell.height = cell_height
+    cell.width = cell_width
+    row += 1 if index.modulo(nb_of_cols).zero?
+    cell.left(index % nb_of_cols * (cell_width + margin) + margin)
+    cell.top(row * (cell_height + margin) + margin)
+  end
+
+  matrix.width = matrix_width + margin
+  matrix.height = matrix_height + margin
+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
+
+    clone.left=3
+    clone.top=3
+    clone.width(cell_height)
+    clone.height(cell_height)
+    sorted[atome_id]=atome_found.atome[sort_by]
+
+
+  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
+end
+
+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  } })
+end
+
+def create_matrix_back( id, style)
+  matrix = Atome.new(
+    shape: { type: :shape, renderers: [:browser], id: id, parents: [:view],width: 333, height: 333,left: 333,
+             overflow: :hidden,children: [] }
+  )
+  matrix.style(style)
+  matrix
+end
+
+
+def create_matrix_cells(id,cell_back_color, number_of_cells, style)
+  counter=0
+  cells=[]
+  while counter < number_of_cells
+    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)
+the_view.display(template: :child_in_table,sort: :id, list: [:the_box,:circle098], left: 33, top: 63, width: 333, height: 333)
+
+  the_view.display({ select: [1, 3, 7], id: :child_in_table })
+

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+
+
+# 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/{build → src}/medias/rubies/examples/parents.rb

@@ -12,4 +12,4 @@ grab(:box_1).parents([:circle_123])
 grab(:color_circle_123).parents([:box_1])
 #
 bb.parents([:box_1])
-grab(:c315).parents([:circle_12])
+grab(:c315).parents([:circle_12])

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+b=box({width: 333, height: 120})
+
+b.size(33)
+
+im= image({path: "./medias/images/boat.png", left: 333, top: 33, width: 333, height: 215})
+im.size(99)

data/vendor/assets/src-tauri/.gitignore

@@ -0,0 +1,4 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+

data/vendor/assets/src-tauri/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "atome"
+version = "0.0.0"
+description = "A Tauri App"
+authors = ["you"]
+license = ""
+repository = ""
+edition = "2021"
+rust-version = "1.57"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[build-dependencies]
+tauri-build = {version = "1.2", features = [] }
+
+[dependencies]
+serde_json = "1.0"
+serde = { version = "1.0", features = ["derive"] }
+tauri = {version = "1.2", features = [] }
+
+[features]
+# by default Tauri runs in production mode
+# when `tauri dev` runs it is executed with `cargo run --no-default-features` if `devPath` is an URL
+default = [ "custom-protocol" ]
+# this feature is used used for production builds where `devPath` points to the filesystem
+# DO NOT remove this
+custom-protocol = [ "tauri/custom-protocol" ]

data/vendor/assets/src-tauri/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+  tauri_build::build()
+}

data/vendor/assets/src-tauri/src/main.rs

@@ -0,0 +1,17 @@
+#![cfg_attr(
+    all(not(debug_assertions), target_os = "windows"),
+    windows_subsystem = "windows"
+)]
+
+// Learn more about Tauri commands at https://tauri.app/v1/guides/features/command
+#[tauri::command]
+fn greet(name: &str) -> String {
+    format!("Hello, {}! You've been greeted from Rust!", name)
+}
+
+fn main() {
+    tauri::Builder::default()
+        .invoke_handler(tauri::generate_handler![greet])
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}