atome 0.5.6.8.6 → 0.5.7.0.2

data/lib/molecules/intuition/utillities.rb

@@ -23,7 +23,7 @@ new(molecule: :input) do |params, bloc|
   attach_to = params[:attach] || default_parent
   renderer_found = grab(attach_to).renderers
   input_back = Atome.new(
-    { renderers: renderer_found,id: new_id, type: :shape, color: back_col,
+    { renderers: renderer_found, id: new_id, type: :shape, color: back_col,
       left: 0, top: 0, data: '', attach: attach_to,
       smooth: 6, overflow: :hidden,
     })
@@ -41,12 +41,11 @@ new(molecule: :input) do |params, bloc|
   end
 
   input_back.touch(:up) do
-    if  input_back.tick[:input] == 1
+    if input_back.tick[:input] == 1
       text_input.component({ selected: true })
     end
   end
 
-
   text_input.keyboard(:down) do |native_event|
     # text_input.component({ selected: { color: :red, text: :red } })
 
@@ -118,12 +117,8 @@ new(molecule: :list) do |params, _bloc|
                    end
   attach_to = params[:attach] || default_parent
   renderer_found = grab(attach_to).renderers
-  list = Atome.new({ renderers: renderer_found,id: new_id, type: :shape,  color: { alpha: 0 }, attach: attach_to }.merge(params))
-  # Atome.new(
-  #     { renderers: [:html], type: :shape, attach: :view, color: back_col,
-  #       left: 0, top: 0, data: '', attach: attach_to,
-  #       smooth: 6, overflow: :hidden,
-  #     })
+  list = Atome.new({ renderers: renderer_found, id: new_id, type: :shape, color: { alpha: 0 }, attach: attach_to }.merge(params))
+
   # now the listing
   listing.each_with_index do |data, index|
     # let's create the container
@@ -147,7 +142,7 @@ new({ molecule: :slider }) do |params, bloc|
   new_id = params.delete(:id) || identity_generator
 
   default_smooth = 9
-  default_slider_particles = {id: new_id, color: color_found, width: 333, height: 33, left: 0, top: 0, smooth: default_smooth }
+  default_slider_particles = { id: new_id, color: color_found, width: 333, height: 33, left: 0, top: 0, smooth: default_smooth }
   default_cursor_particles = { color: color_found, width: 29, height: 29, left: 0, smooth: '100%' }
   cursor_found = params.delete(:cursor)
   slider_particle = default_slider_particles.merge(params)
@@ -186,7 +181,7 @@ new({ molecule: :slider }) do |params, bloc|
       end
       cursor_top_initial = ((max_value - new_value).to_f / (max_value - min_value)) * (slider_particle[:height] - cursor_particle[:height])
       bloc.call(new_value)
-      slider.instance_variable_set('@value',new_value)
+      slider.instance_variable_set('@value', new_value)
       cursor.top(cursor_top_initial)
       cursor.left(cursor_left)
       range.height((slider.height - cursor.top) - cursor.height / 2)
@@ -200,7 +195,7 @@ new({ molecule: :slider }) do |params, bloc|
       end
       cursor_left_initial = ((new_value - min_value).to_f / (max_value - min_value)) * (slider_particle[:width] - cursor_particle[:width])
       bloc.call(new_value)
-      slider.instance_variable_set('@value',new_value)
+      slider.instance_variable_set('@value', new_value)
       cursor.left(cursor_left_initial)
       cursor.top(cursor_top)
       range.width(cursor.left + cursor.width / 2)
@@ -210,11 +205,11 @@ new({ molecule: :slider }) do |params, bloc|
 
   update_value = lambda do |cursor_position, cursor_size, slider_size, orientation|
     effective_slider_size = slider_size - cursor_size
-    if orientation == :vertical
-      percentage = 1.0 - (cursor_position.to_f / effective_slider_size)
-    else
-      percentage = cursor_position.to_f / effective_slider_size
-    end
+    percentage = if orientation == :vertical
+                   1.0 - (cursor_position.to_f / effective_slider_size)
+                 else
+                   cursor_position.to_f / effective_slider_size
+                 end
     value_range = max_value - min_value
     calculated_value = min_value + (value_range * percentage).round
     calculated_value.clamp(min_value, max_value)
@@ -239,7 +234,7 @@ new({ molecule: :slider }) do |params, bloc|
       value = update_value.call(cursor.top, cursor_particle[:height], slider_particle[:height], orientation)
       range.height((slider.height - cursor.top) - cursor.height / 2)
       bloc.call(value)
-      slider.instance_variable_set('@value',value)
+      slider.instance_variable_set('@value', value)
     end
 
   else
@@ -263,7 +258,7 @@ new({ molecule: :slider }) do |params, bloc|
       value = update_value.call(cursor.left, cursor_particle[:width], slider_particle[:width], orientation)
       range.width(cursor.left + cursor.width / 2)
       bloc.call(value)
-      slider.instance_variable_set('@value',value)
+      slider.instance_variable_set('@value', value)
     end
   end
   cursor.touch(:double) do
@@ -282,10 +277,9 @@ end
 new(molecule: :button) do |params, bloc|
   params[:height] ||= 25
   params[:width] ||= 25
-  states=params.delete(:states) || 1
+  states = params.delete(:states) || 1
   new_id = params.delete(:id) || identity_generator
 
-
   back_col = params.delete(:back)
   back_col ||= :grey
 
@@ -297,25 +291,118 @@ new(molecule: :button) do |params, bloc|
   attach_to = params[:attach] || default_parent
   renderer_found = grab(attach_to).renderers
   button = box(
-    { renderers: renderer_found,id: new_id, type: :shape, color: back_col,
+    { renderers: renderer_found, id: new_id, type: :shape, color: back_col,
       left: 0, top: 0, data: '', attach: attach_to,
       smooth: 3, overflow: :hidden,
     })
 
-
-
   button.touch(:down) do
     button.tick(:button)
-    bloc.call(button.tick[:button]%states)
-  end
-
+    bloc.call((button.tick[:button] - 1) % states)
 
+  end
 
   params.each do |part_f, val_f|
     button.send(part_f, val_f)
   end
-  button.left(55)
-
 
   button
 end
+
+new(molecule: :matrix) do |params, &bloc|
+  id = params[:id]
+  rows = params[:rows]
+  columns = params[:columns]
+  spacing = params[:spacing]
+  size = params[:size]
+
+  parent_found = self
+  current_matrix = group({ id: id })
+
+  current_matrix.data({ spacing: spacing, size: size })
+  matrix_cells = []
+  total_spacing_x = spacing * (rows + 1)
+  total_spacing_y = spacing * (columns + 1)
+  size_coefficient = if size.instance_of? String
+                       size.end_with?('%') ? (size.to_f / 100) : size.to_f / parent_found.to_px(:width)
+                     else
+                       size.to_f / parent_found.to_px(:width)
+                     end
+  view_width = parent_found.to_px(:width)
+  view_height = parent_found.to_px(:height)
+  matrix_back = box({ id: "#{id}_background", width: size, height: size, color: { alpha: 0 } })
+
+  if view_width > view_height
+    full_size=view_height * size_coefficient
+    available_width = full_size - total_spacing_x
+    available_height = full_size - total_spacing_y
+    matrix_back.width(full_size)
+    matrix_back.height(full_size)
+  else
+    full_size=view_width * size_coefficient
+    available_width = full_size - total_spacing_x
+    available_height = full_size - total_spacing_y
+    matrix_back.width(full_size)
+    matrix_back.height(full_size)
+  end
+  box_width = available_width / rows
+  box_height = available_height / columns
+
+  columns.times do |y|
+    rows.times do |x|
+      id_generated = "#{id}_#{x}_#{y}"
+      matrix_cells << id_generated
+      new_box = matrix_back.box({ id: id_generated })
+      new_box.width(box_width)
+      new_box.height(box_height)
+      new_box.left((box_width + spacing) * x + spacing)
+      new_box.top((box_height + spacing) * y + spacing)
+    end
+  end
+  current_matrix.collect(matrix_cells)
+  current_matrix
+  # end
+end
+new(molecule: :page) do |params, &bloc|
+
+  b = box({ color: :red, left: 99, drag: true })
+  b.text(params)
+end
+
+new(molecule: :application) do |params, &bloc|
+
+  main_page = box({ drag: true, width: :auto, height: :auto, top: 0, bottom: 0, left: 0, right: 0 })
+
+  main_page
+
+  # def new(params, &bloc)
+  #   if params[:page]
+  #     site_found = grab(params[:page][:application])
+  #     site_found.clear(true)
+  #     page_id = params[:page][:name]
+  #     site_found.box({ id: page_id })
+  #   elsif params[:application]
+  #
+  #     footer_header_size = 33
+  #     footer_header_color = color({ red: 0, green: 0, blue: 0, id: :footer_header_color })
+  #
+  #     if params[:header]
+  #       top = footer_header_size
+  #       header = box({ left: 0, right: 0, width: :auto, top: 0, height: top, id: :header })
+  #       # header.attach(:footer_header_color)
+  #     else
+  #       top = 0
+  #     end
+  #     if params[:footer]
+  #       bottom = footer_header_size
+  #       box({ left: 0, right: 0, width: :auto, top: :auto, bottom: 0, height: bottom, id: :footer })
+  #     else
+  #       bottom = 0
+  #     end
+  #     box({ left: 0, right: 0, width: :auto, top: top, bottom: bottom, height: :auto, id: params[:application] })
+  #   elsif params[:module]
+  #
+  #   end
+  #   super if defined?(super)
+  # end
+end

data/lib/renderers/html/event.rb

@@ -1,8 +1,20 @@
 # frozen_string_literal: true
 
 new({ method: :drag, type: :symbol, renderer: :html }) do |params|
-  option = @drag[params]
-  html.event(:drag, params, option)
+  # if @drag
+  #   option = @drag[params]
+  # else
+  #   params = :remove
+  #   option = true
+  # end
+  # html.event(:drag, params, option)
+
+  if params
+    option = @drag[params]
+    html.event(:drag, params, option)
+  else
+    html.event(:drag, :remove, true)
+  end
 end
 
 new({ method: :drop, type: :symbol, renderer: :html }) do |params|
@@ -11,8 +23,12 @@ new({ method: :drop, type: :symbol, renderer: :html }) do |params|
 end
 
 new({ method: :touch, type: :integer, renderer: :html }) do |params|
-  option = @touch[params]
-  html.event(:touch, params, option)
+  if params
+    option = @touch[params]
+    html.event(:touch, params, option)
+  else
+    html.event(:touch, :remove, true)
+  end
 end
 
 new({ method: :over, type: :integer, renderer: :html }) do |params|