atome 0.5.6.8.7 → 0.5.7.0.2

data/lib/atome/genesis/particles/event.rb

@@ -2,47 +2,53 @@
 
 new({ particle: :touch, category: :event, type: :hash, store: false })
 new({ sanitizer: :touch }) do |params, user_bloc|
-  # TODO: factorise code below
-  # alert  "touch_code: #{@touch_code}"
-  @touch ||= {}
-  @touch_code ||= {}
-  option = true
-  params = if params.instance_of? Hash
-             @touch_code[params.keys[0]] = user_bloc
-             option = params[params.keys[0]]
-             params.keys[0]
-           else
-             case params
-             when true
-               @touch_code[:tap] = user_bloc
-               :tap
-             when :touch
-               @touch_code[:tap] = user_bloc
-               :tap
-             when :down
-               @touch_code[:down] = user_bloc
-               :down
-             when :up
-               @touch_code[:up] = user_bloc
-               :up
-             when :long
-               @touch_code[:long] = user_bloc
-               :long
-             when :double
-               @touch_code[:double] = user_bloc
-               :double
-             when :remove
-               params
-             when false
-               @touch_code[:remove] = user_bloc
-               :remove
+  if params
+    # TODO: factorise code below
+    # alert  "touch_code: #{@touch_code}"
+    @touch ||= {}
+    @touch_code ||= {}
+    option = true
+    params = if params.instance_of? Hash
+               @touch_code[params.keys[0]] = user_bloc
+               option = params[params.keys[0]]
+               params.keys[0]
              else
-               @touch_code[:tap] = user_bloc
-               :tap
+               case params
+               when true
+                 @touch_code[:tap] = user_bloc
+                 :tap
+               when :touch
+                 @touch_code[:tap] = user_bloc
+                 :tap
+               when :down
+                 @touch_code[:down] = user_bloc
+                 :down
+               when :up
+                 @touch_code[:up] = user_bloc
+                 :up
+               when :long
+                 @touch_code[:long] = user_bloc
+                 :long
+               when :double
+                 @touch_code[:double] = user_bloc
+                 :double
+                 # when :remove
+                 #   params
+               when false
+                 @touch_code[:remove] = user_bloc
+                 :remove
+               else
+                 @touch_code[:tap] = user_bloc
+                 :tap
+               end
              end
-           end
-  @touch[params] = option
-  params
+
+    @touch[params] = option
+    params
+  else
+    @touch = false
+    params
+  end
 
 end
 new({ particle: :play, category: :event, type: :boolean, store: false })
@@ -155,6 +161,12 @@ new({ sanitizer: :drag }) do |params, user_bloc|
 
            end
   @drag[params] = option
+  if params == :remove
+    params = false
+  else
+    @drag[params] = option
+  end
+
   params
 end
 new({ particle: :drop, category: :event, type: :boolean, store: false })
@@ -226,14 +238,13 @@ new({ sanitizer: :over }) do |params, user_bloc|
 
            end
 
-    @over[params] = option
+  @over[params] = option
   params
 
 end
 # new({ particle: :sort }) do |_value, sort_proc|
 #   @sort_proc = sort_proc
 # end
-
 new({ particle: :targets, category: :event, type: :string })
 new({ particle: :start, category: :event, type: :boolean })
 new({ pre: :start }) do |_value, user_proc|
@@ -290,12 +301,12 @@ new({ sanitizer: :keyboard }) do |params, user_bloc|
 
   params
 end
-new({ particle: :resize, category: :event, type: :boolean, store: false  })
+new({ particle: :resize, category: :event, type: :boolean, store: false })
 new({ sanitizer: :resize }) do |params, user_bloc|
-  @resize ||= { }
+  @resize ||= {}
   @resize_code ||= {}
 
-  option = {min: { width: 10, height: 10 }, max: { width: 3000, height: 3000 }}
+  option = { min: { width: 10, height: 10 }, max: { width: 3000, height: 3000 } }
   params = if params.instance_of? Hash
              @resize_code[:resize] = user_bloc
              option = params[params.keys[0]]
@@ -323,14 +334,11 @@ new({ particle: :overflow, category: :event, type: :boolean }) do |params, bloc|
   params
 
 end
-
-
-
-new({particle: :animate , category: :event, type: :hash}) do |params|
+new({ particle: :animate, category: :event, type: :hash }) do |params|
   if params.instance_of? Hash
-    params={ from: 0, to: 300, duration: 1000 }.merge(params)
+    params = { from: 0, to: 300, duration: 1000 }.merge(params)
   else
-    params={ from: 0, to: 300, duration: 1000 }
+    params = { from: 0, to: 300, duration: 1000 }
   end
   html.play_animation(params)
 end

data/lib/atome/genesis/particles/identity.rb

@@ -64,8 +64,11 @@ end
 
 new(particle: :selected, category: :identity, type: :boolean) do |params|
   if params == true
+    border({ thickness: 3, red: 1, green: 1, blue: 1, alpha: 1, pattern: :dotted })
+    border({ thickness: 10,  pattern: :solid, color: :red})
     grab(Universe.current_user).selection << @id
   elsif params == false
+    border({alpha: 0, thickness: 0})
     grab(Universe.current_user).selection.collect.delete(@id)
   else
     # TODO: for future use

data/lib/atome/genesis/particles/property.rb

@@ -142,5 +142,6 @@ new({ particle: :value }) do |val|
   val
 end
 
+new({ particle: :behavior })
 
-new({ particle: :behavior })
+new({ particle: :orientation, type: :symbol, category: :property })

data/lib/atome/genesis/particles/utility.rb

@@ -160,13 +160,13 @@ new({ particle: :duplicate, category: :utility, type: :string, store: false }) d
     end
   end
   params[:attached] = attached_atomes
-  infos_found =infos.dup
-  keys_to_delete = [ :history, :callback, :duplicate, :copy, :paste, :touch_code, :html, :attached, :aid]
+  infos_found = infos.dup
+  keys_to_delete = [:history, :callback, :duplicate, :copy, :paste, :touch_code, :html, :attached, :aid]
   keys_to_delete.each { |key| infos_found.delete(key) }
   new_atome_id = "#{@id}_copy_#{copy_number}".to_sym
-  infos_found[:id]=new_atome_id
-  infos_found=infos_found.merge(params)
-  new_atome =Atome.new( infos_found)
+  infos_found[:id] = new_atome_id
+  infos_found = infos_found.merge(params)
+  new_atome = Atome.new(infos_found)
   @duplicate ||= {}
   @duplicate[new_atome_id] = new_atome
   new_atome
@@ -230,25 +230,32 @@ new({ particle: :get, category: :utility, type: :string }) do |params|
   data[row_nb][data[row_nb].keys[column_nb]] # we get the content of the cell
 end
 
-new ({ particle: :css, category: :utility, type: :string })
+new({ particle: :css, category: :utility, type: :string })
 
 new({ read: :css }) do
   CssProxy.new(js, nil, self)
 end
 
-new({particle: :holder, category: :utility, type: :atome})
+new({ particle: :holder, category: :utility, type: :atome })
 
 # this particle is mainly used in conjunction with alternate particle as a 'lambda' to alternate  methods
-new({particle: :executor, category: :utility, type: :hash}) do |params|
+new({ particle: :executor, category: :utility, type: :hash }) do |params|
   params.each do |method, opt|
     send(method, opt)
   end
   params
 end
 
-
-new({ particle: :tick, store: false }) do |val|
-  @tick[val] ||= 1
-  @tick[val]= @tick[val] += 1
+new({ particle: :tick, category: :utility, store: false, type: :hash }) do |val|
+  @tick[val] ||= 0
+  @tick[val] = @tick[val] += 1
   @tick[val]
 end
+
+new({ particle: :storage, category: :utility, type: :hash })
+new({ particle: :state, category: :utility, type: :symbol })
+
+
+new({ particle: :record, category: :utility, type: :hash })
+new({ particle: :preview, category: :utility, type: :hash })
+

data/lib/atome/genesis/presets.rb

@@ -0,0 +1,10 @@
+
+new({preset: :box })
+
+new({preset: :circle })do |params = {},&bloc|
+
+  { type: :shape, width: 39, height: 39, smooth: '100%',
+            apply: [:circle_color],
+            left: 0, top: 0}
+end
+

data/lib/atome/genesis/sparkle.rb

@@ -5,10 +5,10 @@
 # Lets create the U.I.
 default_render = Essentials.default_params[:render_engines]
 Atome.new(
-  { renderers: [], id: :eDen, type: :element, tag: { system: true } }
+  { renderers: [], aid: :eDen, type: :element, tag: { system: true } }
 )
 Atome.new(
-  { renderers: [], id: :user_view, type: :element, tag: { system: true },
+  { renderers: [], aid: :user_view, type: :element, tag: { system: true },
     attach: :eDen }
 )
 
@@ -56,13 +56,13 @@ Atome.new(
 # 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,
+  { renderers: default_render, aid: :black_matter, type: :shape, attach: :user_view,
     left: 0, right: 0, top: 0, bottom: 0, width: 0, height: 0, overflow: :hidden, tag: { system: true }
   })
 
 # view port
 Atome.new(
-  { renderers: default_render, id: :view, type: :shape, attach: :user_view, apply: [:view_color],
+  { renderers: default_render, aid: :view,type: :shape, attach: :user_view, apply: [:view_color],
     tag: { system: true }, left: 0, right: 0, top: 0, bottom: 0, width: :auto, height: :auto, overflow: :auto,
   }
 
@@ -70,7 +70,7 @@ Atome.new(
 
 # unreal port, hold system object and tools
 Atome.new(
-  { renderers: default_render, id: :intuition, type: :shape, attach: :user_view, tag: { system: true },
+  { renderers: default_render, aid: :intuition, type: :shape, attach: :user_view,data: {}, tag: { system: true },
     left: 0, top: 0, bottom: 0, width: 0, height: :auto, overflow: :visible
   }
 )
@@ -80,12 +80,14 @@ machine_id = :dummy_machine
 machine_password = { read: { atome: :star_wars }, write: { atome: :star_wars } }
 
 # copy basket
-Atome.new({ renderers: [:html], id: :copy, collect: [], type: :group, tag: { system: true } })
+Atome.new({ renderers: [:html], aid: :copy, collect: [], type: :group, tag: { system: true } })
 
 # machine
 Atome.new({ renderers: default_render, id: machine_id, type: :machine, password: machine_password,
             name: :macAir, data: { date: '10090717' }, tag: { system: true } })
 
+
+
 # user
 user_password = { global: :star_win, read: { atome: :star_wars }, write: { atome: :star_wars } }
 
@@ -98,7 +100,7 @@ A = Atome.new(
   { renderers: default_render, id: :atome, type: :element, tag: { system: true } }
 )
 # atome selector / collector
-Atome.new({ renderers: [:html], id: :selector, collect: [], type: :group, tag: { system: true } })
+Atome.new({ renderers: [:html], aid: :selector, collect: [], type: :group, tag: { system: true } })
 
 # atome infos
 def atome_infos
@@ -167,7 +169,7 @@ def init_database # this method is call from JS (atome/communication) at WS conn
     # puts "===> #{_db_state}"
   end
 
-  A.sync({ action: :create_db_column, data: { table: :user, column: :email, type: :string } }) do |_db_state|
+  A.sync({ action: :create_db_column, data: { table: :user, column: :email, type: :string, unique: true } }) do |_db_state|
   end
 
   A.sync({ action: :create_db_column, data: { table: :user, column: :password, type: :string } }) do |_db_state|
@@ -210,6 +212,6 @@ def user_login
 
 end
 
-Universe.allow_localstorage = true # to stop data to be stored in localstorage
+# Universe.allow_localstorage = true # to stop data to be stored in localstorage
 # Universe.allow_sync= false # to stop data to be sync on server
 touch_allow(false) # this lock the system right click in web view

data/lib/atome/kernel/universe.rb

@@ -19,14 +19,20 @@ class Universe
   @users = {}
   @help = {}
   @example = {}
-  @allow_localstorage = false
-  @allow_sync = false
-  @connected= false
+  @allow_localstorage = false # temp storage boolean
+  @allow_sync = false # temp server storage sync
+  @connected = false
   @database_ready = false
+  @tools = {}
+  @allow_tool_operations = false
+  @active_tools = []
+  @atome_preset = []
   # @historicize=false
   class << self
-    attr_reader :atomes, :atomes_ids, :renderer_list,:molecule_list, :atome_list, :particle_list, :classes, :counter, :atomes_specificities
-    attr_accessor :connected,:allow_sync, :allow_localstorage, :database_ready
+    attr_reader :atomes, :atomes_ids, :renderer_list, :molecule_list, :atome_list, :particle_list, :classes, :counter,
+                :atomes_specificities
+    attr_accessor :connected, :allow_sync, :allow_localstorage, :database_ready, :edit_mode, :tools,
+                  :allow_tool_operations, :active_tools, :atome_preset
 
     def messages
       @messages
@@ -150,7 +156,7 @@ class Universe
     end
 
     def app_identity
-      # each app hav its own identity, this allow to generate new user identities from the
+      # each app has its own identity, this allow to generate new user identities from the
       # unique_id = generate_unique_id_with_timestamp
       @app_identity = generate_uuid
       # the identity is define as follow : parentsCreatorID_softwareInstanceID_objetID
@@ -257,18 +263,23 @@ class Universe
     def historicize(id, operation, element, params)
 
       if @allow_sync && Universe.connected
-          A.sync({ action: :historicize, data: { table: :user } })
+        A.sync({ action: :historicize, data: { table: :user } })
       end
-      
+
       # if @allow_localstorage && @database_ready
       if @allow_localstorage
-    
+
         operation_timing = Time.now.strftime("%Y%m%d%H%M%S%3N") + @increment.to_s
         @increment += 1
         @increment = @increment % 100
+        # puts "===> { #{id} => { #{operation} => { #{element} => #{params} } }, sync: false }"
+        # puts "<==== #{@allow_localstorage} : #{element} ====>"
+        if @allow_localstorage.include? element
+          JS.global[:localStorage].setItem(operation_timing, "{ #{id} => { #{operation} => { #{element} => #{params} } }, sync: false }")
+          @history[@history.length] = { operation_timing => { id => { operation => { element => params } }, sync: false, time: Time.now } }
+          puts "===> { #{id} => { #{operation} => { #{element} => #{params} } }, sync: false }"
+        end
 
-        JS.global[:localStorage].setItem(operation_timing, "{ #{id} => { #{operation} => { #{element} => #{params} } }, sync: false }")
-        @history[@history.length] = { operation_timing => { id => { operation => { element => params } }, sync: false, time: Time.now } }
 
       end
     end

data/lib/atome/presets/atome.rb

@@ -13,7 +13,7 @@ class Atome
     # TODO : remove Essentials.default_params[atome_preset] || {} as it is
     # applied twice because preset is now a particle
     preset_params = Essentials.default_params[atome_preset] || {}
-
+    # preset_params =  {preset: atome_preset}
     basic_params[:type] = preset_params[:type] || :element
     # basic_params[:aid] =  identity_generator(:a)
     basic_params[:id] = params[:id]|| identity_generator
@@ -37,39 +37,42 @@ class Atome
     else
       params[:attach] = params[:attach] || @id || :view
     end
-    # # we reorder the hash
-    reordered_params =reorder_particles(params)
-    reordered_params
+    # we reorder the hash
+   reorder_particles(params)
   end
 
   def preset_common(params, &bloc)
+
     ## if an atome with current id exist we update the ID in the params
     # params[:id] = "#{params[:id]}_#{Universe.atomes.length}" if grab(params[:id])
     # if Universe.atomes[params[:id]]
     #   alert "atome found : #{ grab(params[:id])}"
     #   grab(params[:id])
     # else
+
     Atome.new(params, &bloc)
     # end
   end
 
-  def box(params = {}, &bloc)
-    atome_preset = :box
-    params = atome_common(atome_preset, params)
-    preset_common(params, &bloc)
-  end
 
-  # def intuition(params = {}, &bloc)
-  #   atome_preset = :intuition
+
+  # def box(params = {}, &bloc)
+  #   atome_preset = :box
+  #   params = atome_common(atome_preset, params)
+  #   preset_common(params, &bloc)
+  # end
+  #
+  # # def intuition(params = {}, &bloc)
+  # #   atome_preset = :intuition
+  # #   params = atome_common(atome_preset, params)
+  # #   preset_common(params, &bloc)
+  # # end
+  #
+  # def circle(params = {}, &bloc)
+  #   atome_preset = :circle
   #   params = atome_common(atome_preset, params)
   #   preset_common(params, &bloc)
   # end
-
-  def circle(params = {}, &bloc)
-    atome_preset = :circle
-    params = atome_common(atome_preset, params)
-    preset_common(params, &bloc)
-  end
 end
 
 

data/lib/atome/utilities/essentials.rb

@@ -17,22 +17,22 @@ module Essentials
     # Warning :  type must be define first
     render_engines: [:html],
     image: { type: :image, left: 0, top: 0},
-    matrix: { type: :matrix, left: 0, top: 0, option: {}},
+    table: { type: :table, left: 0, top: 0, option: {}},
     # FIXME : look at build_atome FIXME to resolve default parent attachment problem
     video: { type: :video },
     animation: { type: :animation, attach: :black_matter },
     element: { type: :element, renderers: [], attach: :black_matter },
     box: { type: :shape, width: 39, height: 39,
            apply: [:box_color],
-           left: 0, top: 0,  preset: :box },
+           left: 0, top: 0 },
     # intuition: { type: :intuition, width: 39, height: 39,
     #        apply: [:box_color],
     #        left: 0, top: 0,  preset: :intuition },
     vector: { type: :vector, width: 39, height: 39,
               left: 0, top: 0,  preset: :vector, definition: corp },
-    circle: { type: :shape, width: 39, height: 39, smooth: '100%',
-              apply: [:circle_color],
-              left: 0, top: 0,  preset: :circle },
+    # circle: { type: :shape, width: 39, height: 39, smooth: '100%',
+    #           apply: [:circle_color],
+    #           left: 0, top: 0,  preset: :circle },
     shape: { type: :shape, width: 39, height: 39,
              apply: [:shape_color],
              left: 0, top: 0 },