atome 0.5.5.9.1 → 0.5.6.0.3

data/lib/renderers/html/html.rb

@@ -210,7 +210,16 @@ class HTML
   end
 
   def connect(params, &bloc)
-    JS.eval("atomeJS.connect('ws://#{params}')")
+    type= params[:type]
+    server= params[:address]
+    user=params[:user]
+    pass=params[:pass]
+    atomes=params[:atomes]
+    particles=params[:particles]
+    JS.eval("atomeJS.connect('#{type}','#{server}','#{user}','#{pass}',#{atomes.to_json},#{particles.to_json})")
+    #
+    # JS.eval("atomeJS.connect('ws://#{server}')")
+    # @original_atome.message(:helloworld)
   end
 
   def send_message(message)
@@ -1475,6 +1484,7 @@ class HTML
 
   def center(options, attach)
     @center_options = options
+
     @parent = grab(attach)
 
     apply_centering(@center_options, @parent)

data/lib/renderers/html/identity.rb

@@ -42,7 +42,8 @@ new({ method: :type, type: :string, specific: :color, renderer: :html }) do
 end
 
 new({ method: :data, type: :string, specific: :text, renderer: :html }) do |params|
-  js[:innerHTML] = if language
+
+  js[:innerHTML] = if int8[language]
                      int8[language].to_s
                    else
                      params.to_s

data/lib/renderers/html/spatial.rb

@@ -1,24 +1,23 @@
 # frozen_string_literal: true
 
 new({ method: :left, type: :integer, renderer: :html }) do |params|
-  unit = @unit[:left] || :px
+  unit = @unit[:left] || :px if params.is_a? Numeric
   js[:style][:left] = "#{params}#{unit}"
 end
 
 new({ method: :top, type: :integer, renderer: :html }) do |params|
-  unit = @unit[:top] || :px
-  # alert  unit
+  unit = @unit[:top] || :px if params.is_a? Numeric
   js[:style][:top] = "#{params}#{unit}"
 end
 new({ method: :bottom, type: :integer, renderer: :html }) do |params|
-  unit = @unit[:bottom] || :px
-  js[:style][:bottom] =  "#{params}#{unit}"
+  unit = @unit[:bottom] || :px if params.is_a? Numeric
+  js[:style][:bottom] = "#{params}#{unit}"
 end
 
 new({ method: :right, type: :integer, renderer: :html }) do |params|
-  unit = @unit[:right] || :px
+  unit = @unit[:right] || :px if params.is_a? Numeric
 
-  js[:style][:right] =  "#{params}#{unit}"
+  js[:style][:right] = "#{params}#{unit}"
 end
 
 new({ method: :top, type: :integer, renderer: :html, specific: :shadow })

data/server/atome_server.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+# atome server
+require 'em/pure_ruby' if RUBY_PLATFORM == 'x64-mingw32'
+require 'fileutils'
+require '../src/utilities/aui'
+require 'digest/sha2'
+require 'faye/websocket'
+require 'geocoder'
+require 'json'
+require 'mail'
+require 'net/ping'
+require 'roda'
+require 'rufus-scheduler'
+require 'securerandom'
+require 'sequel'
+
+class EDen
+  def self.terminal(cmd,option,ws,value, user, pass)
+    `#{cmd}`
+  end
+
+  def self.file(source, operation,ws,value,user, pass)
+    file_content= File.send(operation, source, value).to_s
+    file_content = file_content.gsub("'", "\"")
+    "=> operation: #{operation}, source:  #{source} , content : #{file_content},"
+  end
+  # return_message = EDen.safe_send(action_requested, message,option, current_user, user_pass)
+
+  def self.safe_send(method_name, *args)
+    method_sym = method_name.to_sym
+    eden_methods = EDen.singleton_methods(false) - Object.singleton_methods
+    if eden_methods.include?(method_sym)
+      send(method_sym, *args)
+    else
+      "forbidden action:  #{method_name}"
+    end
+  end
+end
+
+Faye::WebSocket.load_adapter('puma')
+
+class String
+  def is_json?
+    begin
+      !JSON.parse(self).nil?
+    rescue
+      false
+    end
+  end
+end
+
+class Database
+  def self.connect_database
+    if File.exist?("eden.sqlite3")
+      eden = Sequel.connect("sqlite://eden.sqlite3")
+    else
+      eden = Sequel.connect("sqlite://eden.sqlite3")
+      eden.create_table :atome do
+        primary_key :atome_id
+        String :aui
+        String :id
+        String :type
+        String :name
+        String :content
+        String :position
+        String :dimension
+        String :color
+        String :right
+        String :effect
+        String :shadow
+        String :border
+        String :fill
+        Float :x
+        Float :xx
+        Float :y
+        Float :yy
+        Float :z
+        Float :zz
+        Float :width
+        Float :height
+        Float :depth
+      end
+
+    end
+    eden
+  end
+
+end
+
+class App < Roda
+
+  # comment below when test will be done
+  File.delete("./eden.sqlite3") if File.exist?("./eden.sqlite3")
+  eden = Database.connect_database
+  items = eden[:atome]
+
+  # populate the table
+  items.insert(name: 'abc', width: rand * 100)
+  items.insert(name: 'def', width: rand * 100)
+  items.insert(name: 'ghi', width: rand * 100)
+  puts "Item count: #{items.count}"
+  puts "The average price is: #{items.avg(:width)}"
+  index_content = File.read("../src/index_server.html")
+
+  opts[:root] = '../src'
+  plugin :static, %w[/css /js /medias], root: '../src'
+  route do |r|
+    r.root do
+      if Faye::WebSocket.websocket?(r.env)
+        ws = Faye::WebSocket.new(r.env)
+        ws.on :open do |event|
+          ws.send('server ready'.to_json)
+          ws.send('asking for synchro data'.to_json)
+        end
+
+        ws.on(:message) do |event|
+          json_string = event.data.gsub(/(\w+):/) { "\"#{$1}\":" }.gsub('=>', ':')
+          full_data = JSON.parse(json_string)
+
+          message = full_data['message']
+          action_requested = full_data['action']
+          value= full_data['value']
+          option= full_data['option']
+          current_user = full_data['user']
+          user_pass = full_data['pass']['global']
+          # if action_requested == :request
+          #   request (message)
+          # end
+            return_message = EDen.safe_send(action_requested, message,option,ws,value, current_user, user_pass)
+          # else
+          #   return_message = "no action msg: #{full_data}"
+          # end
+          ws.send(return_message.to_json)
+        end
+
+        ws.on(:close) do |event|
+          puts "server closed with status #{event.code}"
+        end
+        ws.rack_response
+      end
+
+      index_content
+    end
+
+  end
+
+end

data/server/atome_server_wasm.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+# atome server
+require 'em/pure_ruby' if RUBY_PLATFORM == 'x64-mingw32'
+require '../src/utilities/aui'
+require 'digest/sha2'
+require 'faye/websocket'
+require 'geocoder'
+require 'json'
+require 'mail'
+require 'net/ping'
+require 'roda'
+require 'rufus-scheduler'
+require 'securerandom'
+require 'sequel'
+
+Faye::WebSocket.load_adapter('puma') # Utilisez l'adaptateur 'thin' pour Faye
+
+class String
+  def is_json?
+    begin
+      !JSON.parse(self).nil?
+    rescue
+      false
+    end
+  end
+end
+
+class Database
+  def self.connect_database
+    if File.exist?("eden.sqlite3")
+      eden = Sequel.connect("sqlite://eden.sqlite3")
+    else
+      eden = Sequel.connect("sqlite://eden.sqlite3")
+      eden.create_table :atome do
+        primary_key :atome_id
+        String :aui
+        String :id
+        String :type
+        String :name
+        String :content
+        String :position
+        String :dimension
+        String :color
+        String :right
+        String :effect
+        String :shadow
+        String :border
+        String :fill
+        Float :x
+        Float :xx
+        Float :y
+        Float :yy
+        Float :z
+        Float :zz
+        Float :width
+        Float :height
+        Float :depth
+      end
+
+    end
+    eden
+  end
+
+end
+
+class App < Roda
+  # comment below when test will be done
+  File.delete("./eden.sqlite3") if File.exist?("./eden.sqlite3")
+  eden = Database.connect_database
+  items = eden[:atome]
+
+  # populate the table
+  items.insert(name: 'abc', width: rand * 100)
+  items.insert(name: 'def', width: rand * 100)
+  items.insert(name: 'ghi', width: rand * 100)
+
+  puts "Item count: #{items.count}"
+
+  puts "The average price is: #{items.avg(:width)}"
+
+  index_content = File.read("../src/index_server.html")
+
+  opts[:root] = '../src'
+  plugin :static, %w[/css /js /medias], root: '../src'
+  route do |r|
+    r.root do
+      if Faye::WebSocket.websocket?(r.env)
+        ws = Faye::WebSocket.new(r.env)
+
+        ws.on :open do |event|
+          ws.send('server ready'.to_json)
+          ws.send('asking for synchro data'.to_json)
+        end
+
+        ws.on(:message) do |event|
+          #TODO : encode event on both client and server
+        ws.send(event.data.reverse.to_json) # Envoie le message inversé au client
+        end
+
+        ws.on(:close) do |event|
+          puts "server closed with status #{event.code}"
+        end
+        ws.rack_response
+      end
+
+      index_content
+    end
+
+  end
+
+end

data/server/capture.rb

@@ -0,0 +1,10 @@
+path = ARGV[0]
+name = ARGV[1]
+
+File.open("#{path}#{name}.txt", 'w') do |f|
+  f.write("Le chemin ; #{path}!\n")
+  f.write("Le nom du fichier #{name}\n")
+end
+
+# `gphoto2 --capture-image-and-download --filename "../src/medias/images/photos/verif.jpg"`
+`gphoto2 --capture-image-and-download --filename "#{path}#{name}.jpg"`

data/server/config.ru

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'roda'
+require 'rack/unreloader'
+
+# Unreloader = Rack::Unreloader.new(subclasses: %w[Roda]) { App }
+# Unreloader.require './atome_server.rb'
+# run Unreloader
+# uncomment to allow code reloading
+# uncomment below for prod or comment to allow code reloading
+require './atome_server.rb'
+run App.app.freeze
+

data/src/css/style.css

@@ -0,0 +1,162 @@
+* {
+    -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
+}
+
+html, body {
+
+    font-family: system-ui, -apple-system, -apple-system-font, 'Segoe UI', 'Roboto', sans-serif;
+    font-size: 12px;
+    margin: 0;
+    padding: 0;
+    background: rgba(39, 39, 39, 1);
+    overflow: hidden;
+    -webkit-overflow-scrolling: touch;
+    width: 100%;
+    height: 100%;
+    z-index: 0;
+    color: lightgray;
+}
+pre {
+    min-width: 100px;
+    margin: 0;
+    padding: 0;
+}
+
+
+.matrix{
+    background-color: blue;
+    border-radius: 9px;
+    display: grid;
+    grid-template-columns: repeat(4, 1fr);
+    flex-direction: column;
+    gap: 12px;
+    padding: 3px;
+}
+/*.matrix_element{*/
+/*    background-color: rebeccapurple;*/
+/*    width: 100%;*/
+/*    height: 29px;*/
+/*    border-radius: 59px;*/
+/*    display: flex;*/
+/*    justify-content: center;*/
+/*    align-items: center;*/
+/*    flex-direction: column;*/
+/*    margin-bottom: 20px;*/
+/*    padding: 0px*/
+/*}*/
+
+#view {
+    left: 0px;
+    font-size: 25px;
+    right: 0px;
+    top: 0px;
+    bottom: 0px;
+    width: auto;
+    /*display: block;*/
+    height: auto;
+    overflow: hidden;
+    position: absolute;
+    -webkit-overflow-scrolling: touch;
+}
+
+
+.ui-selected {
+    border: #00bb00 solid 3px;
+}
+
+.ui-selecting {
+    border: orange solid 3px;
+}
+
+.selected {
+    outline: 2px dashed white;
+    background-color: #00bb00;
+}
+
+.atome {
+    will-change: transform;
+    cursor: default;
+    pointer-events: auto;
+    caret-color: white;
+    outline: none;
+    -webkit-user-select: none;
+    -moz-user-select: none;
+    user-select: none;
+    position: absolute;
+    display: inline-block;
+    background-size: 100%;
+    background-repeat: no-repeat;
+    -webkit-overflow-scrolling: touch;
+    -webkit-user-drag: none;
+    caret-shape: bar;
+    overflow: visible;
+}
+
+.text {
+    /*-webkit-text-fill-color: transparent;*/
+    /*-webkit-background-clip: text;*/
+    word-wrap: break-word;
+    white-space: pre-wrap;
+    position: relative;
+}
+
+.center {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    position: absolute;
+    transform: translate(-50%, -50%);
+}
+
+.center_vertical {
+    display: flex;
+    align-items: center;
+    position: absolute;
+    transform: translateY(-50%);
+}
+
+.center_horizontal{
+    display: flex;
+    justify-content: center;
+    position: absolute;
+    transform: translateX(-50%);
+}
+
+.e_align_h_left {
+    text-align: left;
+}
+
+.e_align_h_right {
+    text-align: right;
+}
+
+.e_align_h_center {
+    text-align: center;
+}
+
+.el_align_h {
+    text-align: justify;
+}
+
+.el_align_v {
+    display: flex;
+    align-items: center;
+}
+
+
+.el_align_v_bottom {
+    display: flex;
+    align-items: flex-end;
+}
+
+/*::selection {*/
+/*    color: transparent;*/
+/*    background: none;*/
+/*}*/
+/*!* For Mozilla Firefox *!*/
+/*::-moz-selection {*/
+/*    color: transparent;*/
+/*    background: none;*/
+/*}*/
+
+

data/src-tauri/.gitignore

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

data/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.5", features = ["api-all"] }
+
+[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/src-tauri/build.rs

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

data/src-tauri/src/main.rs

@@ -0,0 +1,71 @@
+use std::process::Command;
+use std::str;
+use std::fs;
+
+// 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)
+}
+
+#[tauri::command]
+fn execute_command(command: &str) -> Result<String, String> {
+    match Command::new("sh")
+        .arg("-c")
+        .arg(command)
+        .output()
+    {
+        Ok(output) => {
+            if output.status.success() {
+                Ok(str::from_utf8(&output.stdout).unwrap().to_string())
+            } else {
+                Err(str::from_utf8(&output.stderr).unwrap().to_string())
+            }
+        }
+        Err(error) => Err(error.to_string()),
+    }
+}
+
+#[tauri::command]
+fn read_file(file_path: &str) -> Result<String, String> {
+    let content = match fs::read_to_string(file_path) {
+        Ok(content) => content,
+        Err(_) => return Err("Failed to read file.".to_string()),
+    };
+    Ok(content)
+}
+
+#[tauri::command]
+fn write_file(file_path: &str, content: &str) -> Result<(), String> {
+    let path = std::path::Path::new(file_path);
+    match fs::write(path, content) {
+        Ok(_) => Ok(()),
+        Err(_) => Err("Failed to write to the file.".to_string()),
+    }
+}
+
+// Nouvelle commande pour lister le contenu du répertoire
+#[tauri::command]
+fn list_directory_content(directory_path: String) -> Result<Vec<String>, String> {
+    let path = std::path::Path::new(&directory_path);
+    match fs::read_dir(path) {
+        Ok(entries) => {
+            let entries: Vec<String> = entries
+                .filter_map(|entry| {
+                    entry.ok().and_then(|e| {
+                        e.path().file_name().and_then(std::ffi::OsStr::to_str).map(|s| s.to_owned())
+                    })
+                })
+                .collect();
+            Ok(entries)
+        }
+        Err(_) => Err("Failed to read directory.".to_string()),
+    }
+}
+
+fn main() {
+    tauri::Builder::default()
+        .invoke_handler(tauri::generate_handler![greet, execute_command, read_file, write_file, list_directory_content])
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}