atome 0.5.6.8.7 → 0.5.7.0.2

data/lib/atome/utilities/utilities.rb

@@ -6,6 +6,7 @@ require 'json'
 class Atome
   class << self
     attr_accessor :initialized
+
     def sanitize_data_for_json(data)
       data = data.gsub('"', '\\"')
       # case data
@@ -21,13 +22,12 @@ class Atome
       data
     end
 
-
     def send_localstorage_content
       storage = JS.global[:localStorage]
       storage_array = storage.to_a
       storage_array.each_with_index do |_i, index|
         key = JS.global[:localStorage].key(index)
-         sanitize_data_for_json(storage.getItem(key))
+        sanitize_data_for_json(storage.getItem(key))
       end
     end
 
@@ -49,6 +49,26 @@ class Atome
       JS.eval(js_command)
     end
 
+    # atome builder
+    def preset_builder(preset_name, &bloc)
+      # Important : previously def box , def circle
+      Universe.atome_preset << preset_name
+      Object.define_method preset_name do |params = {}, &proc|
+        grab(:view).send(preset_name, params, &proc)
+      end
+      define_method preset_name do |params|
+        preset_to_add = instance_exec(params, &bloc) if bloc.is_a? Proc
+        if Essentials.default_params[preset_name]
+          Essentials.default_params[preset_name].merge(preset_to_add) if preset_to_add
+        else
+          Essentials.default_params[preset_name] = preset_to_add if preset_to_add
+        end
+        params = atome_common(preset_name, params)
+        preset_common(params, &bloc)
+      end
+
+    end
+
     # monitoring system
     def monitoring(atomes_to_monitor, particles_to_monitor, &bloc)
       atomes_to_monitor.each do |atome_to_monitor|
@@ -81,6 +101,18 @@ class Atome
       end
     end
 
+    def controller_listener
+      return if $host == :html
+      atome_js.JS.controller_listener() # js folder atome/helipers/atome/communication
+    end
+
+    def handleSVGContent(svg_content, target)
+      puts svg_content
+      atome_content = A.vectorizer(svg_content)
+      target_vector = grab(target)
+      target_vector.data(atome_content)
+    end
+
   end
 
   @initialized = {}
@@ -114,12 +146,6 @@ class Atome
     send(js_action, js_body)
   end
 
-  def self.controller_listener
-    return if $host == :html
-
-    atome_js.JS.controller_listener() # js folder atome/helipers/atome/communication
-  end
-
   def collapse(new_atome)
     initialized_procs = []
     initialized = Atome.initialized
@@ -127,13 +153,13 @@ class Atome
     new_atome.each do |element, value|
       send(element, value)
       initialized_proc = initialized[element]
-      initialized_procs << {value => initialized_proc } if initialized_proc.is_a?(Proc)
+      initialized_procs << { value => initialized_proc } if initialized_proc.is_a?(Proc)
     end
 
     initialized_procs.each do |value|
-       value.each do |val, proc|
-         instance_exec(val, &proc)
-       end
+      value.each do |val, proc|
+        instance_exec(val, &proc)
+      end
     end
 
   end
@@ -318,6 +344,23 @@ class Atome
     send("#{element}_callback", return_params)
   end
 
+  def js_callback(id, particle, value,sub=nil )
+    current_atome= grab(id)
+   #  # alert current_atome.instance_variable_get('@record_code')
+    proc_found= current_atome.instance_variable_get("@#{particle}_code")[particle.to_sym]
+    # proc_found= current_atome.instance_variable_get("@record_code")[:record]
+   #  # alert particle.class
+   #  # alert proc_found.class
+    # proc_found.call
+   instance_exec(value, &proc_found) if proc_found.is_a?(Proc)
+   # #  # puts "params to be exec #{id}, #{particle}, #{value}, #{sub}"
+   #  alpha= grab(:the_big_box)
+   #  proc_found= alpha.instance_variable_get("@record_code")[:record]
+    # proc_found.call
+
+  end
+
+
   # def callback(data)
   #   @callback[data.keys[0]] = data[data.keys[0]]
   # end
@@ -431,7 +474,6 @@ class Atome
     end
   end
 
-
   def init_websocket
     connection(@current_server)
   end
@@ -458,8 +500,6 @@ class Atome
     storage_items
   end
 
-
-
   # def to_sym
   #   puts "sanitizer temp patch when an atome is passed instead of an id"
   #   @id
@@ -491,7 +531,120 @@ class Atome
     current_state
   end
 
+  def vectorizer(svg_content)
+    atome_content = []
+
+    # circle_regex = /<circle\s+.*?id\s*=\s*"(.*?)"\s+(?:stroke\s*=\s*"(.*?)"\s+)?(?:stroke-width\s*=\s*"(.*?)"\s+)?fill\s*=\s*"(.*?)"\s+cx\s*=\s*"(\d+)"\s+cy\s*=\s*"(\d+)"\s+r\s*=\s*"(\d+)".*?\/>/
+    circle_regex = /<circle\s+.*?id\s*=\s*"(.*?)"\s+(?:stroke\s*=\s*"(.*?)"\s+)?(?:stroke-width\s*=\s*"(.*?)"\s+)?fill\s*=\s*"(.*?)"\s+cx\s*=\s*"(\d+(?:\.\d+)?)"\s+cy\s*=\s*"(\d+(?:\.\d+)?)"\s+r\s*=\s*"(\d+(?:\.\d+)?)"\s*.*?\/>/
+
+    svg_content.scan(circle_regex) do |id, stroke, stroke_width, fill, cx, cy, r|
+      stroke = stroke || 'none'
+      stroke_width = stroke_width || '0'
+      fill = fill || 'none'
+      circle_def = { circle: { cx: cx, cy: cy, r: r, id: id, stroke: stroke, "stroke-width" => stroke_width, fill: fill } }
+      atome_content << circle_def
+    end
+
+    # path_regex = /<path\s+.*?d\s*=\s*"([^"]+)"\s+(?:id\s*=\s*"(.*?)"\s+)?(?:stroke\s*=\s*"(.*?)"\s+)?(?:stroke-width\s*=\s*"(.*?)"\s+)?fill\s*=\s*"(.*?)".*?\/>/
+    path_regex = /<path\s+.*?d\s*=\s*"([^"]+)"\s+(?:id\s*=\s*"(.*?)"\s+)?(?:stroke\s*=\s*"(.*?)"\s+)?(?:stroke-width\s*=\s*"(.*?)"\s+)?fill\s*=\s*"(.*?)".*?\/>/
+
+    svg_content.scan(path_regex) do |d, id, stroke, stroke_width, fill|
+      id = id || 'path_id'
+      stroke = stroke || 'none'
+      stroke_width = stroke_width || '0'
+      fill = fill || 'none'
+      path_def = { path: { d: d, id: id, stroke: stroke, 'stroke-width' => stroke_width, fill: fill } }
+      atome_content << path_def
+    end
+
+    # rect_regex = /<rect\s+.*?id\s*=\s*"(.*?)"\s+(?:stroke\s*=\s*"(.*?)"\s+)?(?:stroke-width\s*=\s*"(.*?)"\s+)?fill\s*=\s*"(.*?)"\s+x\s*=\s*"(\d+)"\s+y\s*=\s*"(\d+)"\s+width\s*=\s*"(\d+)"\s+height\s*=\s*"(\d+)".*?\/>/
+    rect_regex = /<rect\s+.*?id\s*=\s*"(.*?)"\s+(?:stroke\s*=\s*"(.*?)"\s+)?(?:stroke-width\s*=\s*"(.*?)"\s+)?fill\s*=\s*"(.*?)"\s+x\s*=\s*"(\d+(?:\.\d+)?)"\s+y\s*=\s*"(\d+(?:\.\d+)?)"\s+width\s*=\s*"(\d+(?:\.\d+)?)"\s+height\s*=\s*"(\d+(?:\.\d+)?)"\s*.*?\/>/
+
+    svg_content.scan(rect_regex) do |id, stroke, stroke_width, fill, x, y, width, height|
+      id = id || 'rect_id'
+      stroke = stroke || 'none'
+      stroke_width = stroke_width || '0'
+      fill = fill || 'none'
+      rect_def = { rect: { x: x, y: y, width: width, height: height, id: id, stroke: stroke, 'stroke-width' => stroke_width, fill: fill } }
+      atome_content << rect_def
+    end
+
+    # line_regex = /<line\s+.*?id\s*=\s*"(.*?)"\s+(?:stroke\s*=\s*"(.*?)"\s+)?(?:stroke-width\s*=\s*"(.*?)"\s+)?x1\s*=\s*"(\d+)"\s+y1\s*=\s*"(\d+)"\s+x2\s*=\s*"(\d+)"\s+y2\s*=\s*"(\d+)".*?\/>/
+    line_regex = /<line\s+.*?id\s*=\s*"(.*?)"\s+(?:stroke\s*=\s*"(.*?)"\s+)?(?:stroke-width\s*=\s*"(.*?)"\s+)?x1\s*=\s*"(\d+(?:\.\d+)?)"\s+y1\s*=\s*"(\d+(?:\.\d+)?)"\s+x2\s*=\s*"(\d+(?:\.\d+)?)"\s+y2\s*=\s*"(\d+(?:\.\d+)?)"\s*.*?\/>/
+
+    svg_content.scan(line_regex) do |id, stroke, stroke_width, x1, y1, x2, y2|
+      id = id || 'line_id'
+      stroke = stroke || 'none'
+      stroke_width = stroke_width || '0'
+      line_def = { line: { x1: x1, y1: y1, x2: x2, y2: y2, id: id, stroke: stroke, 'stroke-width' => stroke_width } }
+      atome_content << line_def
+    end
+
+    # ellipse_regex = /<ellipse\s+.*?id\s*=\s*"(.*?)"\s+(?:stroke\s*=\s*"(.*?)"\s+)?(?:stroke-width\s*=\s*"(.*?)"\s+)?fill\s*=\s*"(.*?)"\s+cx\s*=\s*"(\d+)"\s+cy\s*=\s*"(\d+)"\s+rx\s*=\s*"(\d+)"\s+ry\s*=\s*"(\d+)".*?\/>/
+    ellipse_regex = /<ellipse\s+.*?id\s*=\s*"(.*?)"\s+(?:stroke\s*=\s*"(.*?)"\s+)?(?:stroke-width\s*=\s*"(.*?)"\s+)?fill\s*=\s*"(.*?)"\s+cx\s*=\s*"(\d+(?:\.\d+)?)"\s+cy\s*=\s*"(\d+(?:\.\d+)?)"\s+rx\s*=\s*"(\d+(?:\.\d+)?)"\s+ry\s*=\s*"(\d+(?:\.\d+)?)"\s*.*?\/>/
+
+    svg_content.scan(ellipse_regex) do |id, stroke, stroke_width, fill, cx, cy, rx, ry|
+      id = id || 'ellipse_id'
+      stroke = stroke || 'none'
+      stroke_width = stroke_width || '0'
+      fill = fill || 'none'
+      ellipse_def = { ellipse: { cx: cx, cy: cy, rx: rx, ry: ry, id: id, stroke: stroke, 'stroke-width' => stroke_width, fill: fill } }
+      atome_content << ellipse_def
+    end
+
+    # polygon_regex = /<polygon\s+(?:id\s*=\s*"(.*?)"\s+)?(?:stroke\s*=\s*"(.*?)"\s+)?(?:stroke-width\s*=\s*"(.*?)"\s+)?(?:fill\s*=\s*"(.*?)"\s+)?points\s*=\s*"([^"]+)".*?\/>/
+    polygon_regex = /<polygon\s+(?:id\s*=\s*"(.*?)"\s+)?(?:stroke\s*=\s*"(.*?)"\s+)?(?:stroke-width\s*=\s*"(.*?)"\s+)?(?:fill\s*=\s*"(.*?)"\s+)?points\s*=\s*"([^"]+)".*?\/>/
+    svg_content.scan(polygon_regex) do |id, stroke, stroke_width, fill, points|
+      id ||= 'polygon_id'
+      stroke ||= 'none'
+      stroke_width ||= '0'
+      fill ||= 'none'
+      polygon_def = { polygon: { points: points, id: id, stroke: stroke, 'stroke-width' => stroke_width, fill: fill } }
+      atome_content << polygon_def
+    end
+
+    polyline_regex = /<polyline\s+.*?points\s*=\s*"([^"]+)"\s+(?:id\s*=\s*"(.*?)"\s+)?(?:stroke\s*=\s*"(.*?)"\s+)?(?:stroke-width\s*=\s*"(.*?)"\s+)?(?:fill\s*=\s*"(.*?)")?.*?\/>/
+    svg_content.scan(polyline_regex) do |points, id, stroke, stroke_width, fill|
+      id ||= 'polyline_id'
+      stroke ||= 'none'
+      stroke_width ||= '0'
+      fill ||= 'none'
+      polyline_def = { polyline: { points: points, id: id, stroke: stroke, 'stroke-width' => stroke_width, fill: fill } }
+      atome_content << polyline_def
+    end
+
+    atome_content
+  end
+
+  def b64_to_tag(params)
+    unless params[:target]
+      new_img = image({ left: 0, top: 0 })
+      params[:target] = new_img.id
+    end
+    new_tag = <<STRR
+  var serializer = new XMLSerializer();
+  var svg_string = serializer.serializeToString(document.getElementById('#{params[:id]}'));
+  var encoded_svg = btoa(unescape(encodeURIComponent(svg_string)));
+  var img = document.getElementById('#{params[:target]}');
+  img.src = "data:image/svg+xml;base64," + encoded_svg;
+  var parent = document.getElementById('#{id}');
+  parent.appendChild(img);
+STRR
+    JS.eval(new_tag)
+    new_atome = grab(params[:target])
+    html_obj = new_atome.html.object
+    obj_src = html_obj[:src]
+    new_atome.path(obj_src)
+    new_atome
+  end
 
+  def fetch_svg(params)
+    source = params[:source]
+    img_element = JS.global[:document].getElementById(source.to_s)
+    svg_path = img_element.getAttribute("src")
+    target = params[:target]
+    JS.eval("fetchSVGContent('#{svg_path}', '#{target}')")
+  end
 
 end
 

data/lib/atome/version.rb

@@ -2,5 +2,5 @@
 
 #  return atome version
 class Atome
-  VERSION = '0.5.6.8.7'
+  VERSION = '0.5.7.0.2'
 end

data/lib/atome.rb

@@ -34,6 +34,7 @@ require 'renderers/html/index'
 require 'renderers/headless/index'
 require 'renderers/server/index'
 require 'atome/utilities/sanitizer'
+require 'atome/genesis/presets'
 require 'atome/genesis/sparkle'
 require 'molecules/init'
 require 'molecules/intuition/utillities'

data/lib/atome_relative.rb

@@ -33,6 +33,7 @@ require_relative './renderers/html/index_relative'
 require_relative './renderers/headless/index_relative'
 require_relative './renderers/server/index_relative'
 require_relative './atome/utilities/sanitizer'
+require_relative './atome/genesis/presets'
 require_relative './atome/genesis/sparkle'
 require_relative './molecules/init'
 require_relative './molecules/intuition/utillities'

data/lib/molecules/init.rb

@@ -1,48 +1,28 @@
 # frozen_string_literal: true
 
 module Molecule
-  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
-
-  class Object
-    include Molecule
-  end
-
-  # tests
-  # new({application: :compose, header: true, footer: true })
-  #
-  # new(page: {name: :home, application: :compose, attach: :root })
-  #
-  # new(module: {name: :home, application: :compose, attach: :root })
+
+end
+
+class Object
+  include Molecule
+  # we add a getter for the molecule in standard ruby Object
+  # def molecule
+  #   @molecule
+  # end
+end
+
+class Atome
+  include Molecule
+end
+
+
+# tests
+# new({application: :compose, header: true, footer: true })
+#
+# new(page: {name: :home, application: :compose, attach: :root })
+#
+# new(module: {name: :home, application: :compose, attach: :root })
 
 
 

data/lib/molecules/intuition/_deprecated_inputs.rb

@@ -0,0 +1,111 @@
+# # frozen_string_literal: true
+#
+# # def atome_common(atome_preset, params)
+# #   basic_params = { renderers: [] }
+# #   # 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] || {}
+# #
+# #   basic_params[:type] = preset_params[:type] || :element
+# #   basic_params[:id] = params[:id] || identity_generator(atome_preset)
+# #   basic_params[:renderers] = @renderers || preset_params[:renderers]
+# #   essential_params = basic_params.merge(preset_params)
+# #   reordered_params = essential_params.reject { |key, _| params.has_key?(key) }
+# #   params = reordered_params.merge(params)
+# #
+# #   # condition to handle color/shadow/paint atomes that shouldn't be attach to view
+# #   # TODO : add category for atome( material/physical vs modifier : color, shadow, .. vs shape, image ..)
+# #   # then add condition same things fo code in genesis new_atome
+# #   if %i[color shadow paint].include?(atome_preset)
+# #     unless params[:affect]
+# #       params[:affect] = if @id == :view
+# #                           [:black_matter]
+# #                         else
+# #                           [@id]
+# #                         end
+# #     end
+# #   else
+# #     params[:attach] = params[:attach] || @id || :view
+# #   end
+# #   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])
+# #   Atome.new(params, &bloc)
+# # end
+# # class EVe < Atome
+# class EVe < Atome
+#   def initialize
+#     @atomes = {}
+#   end
+#
+#   def atome(atome_to_find)
+#     @atomes[atome_to_find]
+#   end
+#
+#   def input_box(params = {}, &bloc)
+#     height_wanted = 15
+#     width_wanted = 222
+#     input_back = Atome.new(
+#       { renderers: [:html], id: :input_back, type: :shape, attach: :view, apply: [:shape_color],
+#         left: 120, top: 120,data: '', width: width_wanted, height: height_wanted + height_wanted * 20 / 100, smooth: 6 })
+#
+#     @atomes[:input_back] = input_back
+#
+#     Atome.new(
+#       { renderers: [:html], id: :input_text_color, type: :color, tag: ({ system: true, persistent: true }),
+#         red: 0.1, green: 0.1, blue: 0.1, alpha: 1 }
+#     )
+#
+#     text_input = Atome.new(
+#       { renderers: [:html], id: :input_text, type: :text, apply: [:input_text_color], component: { size: height_wanted },
+#         data: :input, left: height_wanted * 20 / 100, top: 0, edit: true, attach: :input_back, height: height_wanted, position: :absolute })
+#
+#     text_input.touch(true) do
+#       text_input.component({ selected: { color: 'rgba(0,0,0,0.3)', text: :orange } })
+#     end
+#
+#     text_input.keyboard(:down) do |native_event|
+#       event = Native(native_event)
+#       if event[:keyCode].to_s == '13'
+#         # we prevent the input
+#         event.preventDefault()
+#       end
+#
+#     end
+#
+#     text_input.keyboard(:up) do |native_event|
+#       input_back.data=text_input.data
+#     end
+#     @atomes[:input_text] = text_input
+#
+#     input_back
+#   end
+#
+# end
+#
+# def input(params = {}, &proc)
+#   text_color = :white
+#   text_size = 12
+#   back_color = :gray
+#   width = 2000
+#   in_b = EVe.new()
+#   in_b.input_box
+# end
+#
+# i= input
+#
+# b=box({top: 0, left: 0, width: 33, height: 33})
+# b.touch(true) do
+#   puts "i.data : #{i.data}"
+# end
+# i.left(66)
+# i.color(:white)
+# i.text.left(55)
+#
+#
+#
+#
+#

data/lib/molecules/intuition/utillities.rb

@@ -118,11 +118,7 @@ new(molecule: :list) do |params, _bloc|
   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,
-  #     })
+
   # now the listing
   listing.each_with_index do |data, index|
     # let's create the container
@@ -209,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)
@@ -302,7 +298,7 @@ new(molecule: :button) do |params, bloc|
 
   button.touch(:down) do
     button.tick(:button)
-    bloc.call((button.tick[:button]-1) % states)
+    bloc.call((button.tick[:button] - 1) % states)
 
   end
 
@@ -312,3 +308,101 @@ new(molecule: :button) do |params, bloc|
 
   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|