hokusai-zero 0.2.6.pre.pinephone2 → 0.2.6.pre.pinephone3

data/ui/src/hokusai/blocks/slider.rb

@@ -0,0 +1,139 @@
+
+module Hokusai::Blocks
+  class Slider < Hokusai::Block
+    template <<~EOF
+    [template]
+      empty {
+        @click="start_slider"
+        @mousemove="move_slider"
+        @mouseup="stop_slider"
+      }
+    EOF
+
+    uses(empty: Hokusai::Blocks::Empty)
+
+    computed :fill, default: [61,171,211], convert: Hokusai::Color
+    computed :initial, default: 0.0, convert: proc(&:to_f)
+    computed :size, default: 50.0, convert: proc(&:to_f)
+    computed :step, default: 20.0, convert: proc(&:to_f)
+    computed :min, default: 0.0, convert: proc(&:to_f)
+    computed :max, default: 100.0, convert: proc(&:to_f)
+
+    attr_reader :slider_width, :slider_start, :steps_x, :steps_val
+    attr_accessor :sliding, :slider_x, :last_index
+
+    def initialize(**args)
+      @sliding = false
+      @slider_width = 0.0
+      @slider_start = 0.0
+      @slider_x = 0.0
+      @last_index = 0
+      @configured = false
+
+      super
+
+      @last_max = nil
+    end
+
+    def start_slider(event)
+      self.sliding = true
+    end
+
+    def on_resize(canvas)
+      # create our buckets for steps
+      @slider_start = canvas.x
+      @slider_width = canvas.width
+
+      @steps_val = [*(min..max).step(step).to_a, max]
+      steps_val.pop if steps_val[-1] == steps_val[-2]
+
+      step_x = (slider_width) / (steps_val.size - 1)
+      @steps_x = (slider_start..(slider_start + slider_width)).step(step_x).to_a
+
+      (steps_val.size - steps_x.size).times do |i|
+        steps_x << steps_x.last + step_x * i
+      end
+
+      steps_x[-1] = slider_start + slider_width  if slider_start + slider_width != steps_x.last
+    end
+
+    def move_slider(event)
+      if sliding && event.left.down
+        pos = event.pos.x
+        index = steps_x.size - 1
+    
+        (0...steps_x.size - 1).each do |i|
+          next if steps_x[i + 1] && pos - steps_x[i + 1] > step
+
+          if pos - steps_x[i] > pos - steps_x[i + 1]
+            index = i
+            break 
+          else
+            index = i + 1
+            break
+          end
+        end
+
+        self.last_index = index
+
+        emit("updated", steps_val[index])
+      else
+        self.sliding = false
+      end
+    end
+
+    def stop_slider(event)
+      if event.left.up
+        self.sliding = false
+      end
+    end
+
+    def render(canvas)
+      if max != @last_max
+        on_resize(canvas)
+
+        @last_max = max
+      end
+
+      unless @setup || steps_val.nil? || initial.nil?
+        steps_val.each_with_index do |val, index|
+          if val == initial
+            self.last_index = index
+
+            break
+          end
+        end
+
+        @setup = true
+      end
+
+      slider_x = steps_x[last_index]
+      padding = Hokusai::Padding.new(0.0, 0.0, 0.0, 0.0)
+      percent = slider_x * 100.00
+      x = slider_x  + padding.left
+      x = (canvas.x + canvas.width) - (size / 2) - 2 if x > (canvas.x + canvas.width) - (size / 2)
+      x = canvas.x  if x < canvas.x
+      cursor = (x + size / 2)
+
+      draw do
+        # draw background
+        rect(canvas.x + padding.left, canvas.y + padding.top, canvas.width - padding.right - padding.left, size) do |command|
+          command.round = size / 2
+          command.color = Hokusai::Color.new(33, 33, 33)
+          command.padding = Hokusai::Padding.new(5.0, 20.0, 5.0, 20.0)
+        end
+
+        rect(canvas.x + padding.left + 1, canvas.y + padding.top + 1, x + (size / 2) - canvas.x - 2, size - 2) do |command|
+          command.round = size / 2
+          command.color = fill
+        end
+
+        circle(cursor + padding.left, canvas.y + (size / 2) + padding.top, size / 2) do |command|
+          command.color = Hokusai::Color.new(233, 233, 233)
+        end
+      end
+      
+      yield canvas
+    end
+  end
+end

data/ui/src/hokusai/commands/rect.rb

@@ -11,8 +11,8 @@ module Hokusai
       @height = height.to_f
       @outline = Outline.default
       @rounding = 0.0
-      @color = Color.new(0, 0, 0, 0)
-      @outline_color = Color.new(0, 0, 0, 255)
+      @color = Color.new(255, 255, 255, 0)
+      @outline_color = Color.new(0, 0, 0, 0)
       @padding = Padding.new(0.0, 0.0, 0.0, 0.0)
       @gradient = nil
     end

data/ui/src/hokusai/events/touch.rb

@@ -2,9 +2,9 @@ module Hokusai
   class TouchEvent < Event
     extend Forwardable
 
-    def_delegators :@touch, :tapped?, :swiped?, :longtapped?, :touching?,
-                   :duration, :direction, :angle, :position, :last_position,
-                  :touch_len, :touch_count, :timer
+    def_delegators :@touch, :tapped?, :swiped?, :longtapped?, :longtapping?, :touching?,
+                   :duration, :direction, :distance, :angle, :position, :last_position,
+                   :touch_len, :touch_count, :timer
 
     attr_reader :input
 
@@ -32,14 +32,8 @@ module Hokusai
     name "taphold"
 
     def capture(block, canvas)
-      if longtapped? && hovered(canvas)
-        block.node.meta.focus
-        
-        if matches(block)
-          captures << block
-        end
-      elsif touching?
-        block.node.meta.blur
+      if matches(block) && longtapped? && hovered(canvas) 
+        captures << block
       end
     end
   end

data/ui/src/hokusai/painter.rb

@@ -277,7 +277,7 @@ module Hokusai
       end
       events[:mousemove].capture(block, canvas)
 
-      if block_is_hovered || block.node.meta.focused
+      if block_is_hovered || block.node.meta.focused || input.keyboard_override
         events[:keyup].capture(block, canvas)
         events[:keypress].capture(block, canvas)
       end

data/ui/src/hokusai/types.rb

@@ -96,6 +96,14 @@ module Hokusai
     alias_method :r, :right
     alias_method :b, :bottom
 
+    def width
+      right + left
+    end
+
+    def height
+      top + bottom
+    end
+
     def self.convert(value)
       case value
       when String
@@ -241,90 +249,183 @@ module Hokusai
   end
 
   class Touch
-    attr_reader :raw
+    attr_accessor :stack, :archive
+    def initialize
+      @stack = []
+      @archive = []
+      @tapped = false
+      @swiped = false
+      @pinched = false
+      # @file = File.open("touch.log", "w")
+    end
 
-    [
-      :touch_len, :touch_count, :touching_now, :timer, 
-    ].each do |key|
-      define_method(key) do
-        raw[:touch][key]
-      end
+    def tapped?
+      @tapped
     end
 
     def swiped?
-      LibHokusai.hoku_input_touch_swiped(raw)
+      @swiped
     end
 
+    def pinched?
+      @pinched
+    end
+
+    def longtapping?(stuff = "ok")
+      log("#{touching?} - #{elapsed(token)} - #{stuff}") if touching?
+      touching? && elapsed(token) > 5
+    end
+    
     def longtapped?
-      LibHokusai.hoku_input_touch_longtapped(raw)
+      @longtapped
+    end
+
+    def touching?
+      type == :down || type == :move
     end
 
-    # return [Intger] duration in milliseconds
     def duration
-      LibHokusai.hoku_input_touch_duration(raw)
+      if longtapping?
+        return elapsed(token)
+      end
+      
+      first, last = archive[-2..-1]
+
+      last[:start] - first[:start]
     end
 
-    def touching?
-      touching_now
+    def distance
+      raise Hokusai::Error.new("Archive is empty") if archive.empty?
+      first, last = archive[-2..-1]
+      
+      x = last[:x] - first[:x]
+      y = last[:y] - first[:y]
+
+      [x, y]
     end
 
-    def tapped?
-      LibHokusai.hoku_input_touch_tapped(raw)
+    def direction
+      raise Hokusai::Error.new("Archive is empty") if archive.empty?
+
+      first, last = archive[-2..-1]
+      
+      x = last[:x] - first[:x]
+      y = last[:y] - first[:y]
+
+      if x.abs > y.abs
+        # swiping left/right
+        last[:x] > first[:x] ? :right : :left
+      else
+        # swiping up/down
+        last[:y] > first[:y] ? :down : :up
+      end
     end
 
-    def position(index=0)
-      touches[index]
+    def angle
+      raise Hokusai::Error.new("Archive is empty") if archive.empty?
+
+      last, first = archive[-2..-1]
+      
+      x = last[:x] - first[:x]
+      y = last[:y] - first[:y]
+
+      (Math.atan2(x, y) * (-180 / Math::PI)).round(0).to_i
     end
 
-    def last_position(index=0)
-      last_touches[index]
+    def log(str)
+      # Thread.new do
+      #   @file.write_nonblock("#{str}\n")
+      # end
     end
 
-    def angle(index = 0)
-      return nil unless swiped?
+    def record(finger, x, y)
+      log("recording #{token}")
+      if type == :down
+        push(:move, finger, x, y)
+        log("state is move")
+      elsif type == :move
+        stack.last[:x] = x
+        stack.last[:y] = y
+        
+        log("updated state move")
+      else 
+        @longtapped = false
+        @swiped = false
+        @tapped = false
+        push(:down, finger, x, y)
+        log("state is down")
+      end
+    end
 
-      pos = position(index)
-      lpos = last_position(index)
+    def clear
+      log("clearing")
+      if type == :move
+        log("elapsed: #{elapsed(token)}")
+        if elapsed(token) > 0.05 && within(10.0)
+          @longtapped = true
+          log('longtap')
+        else
+          @swiped = true
+          log('swipe')
+        end
+      elsif type == :down
+        @tapped = true
+        log('tap')
+      else
+        @longtapped = false
+        @swiped = false
+        @tapped = false
+      end
 
-      x = position.x - last_position.x
-      y = position.y - last_position.y
+      self.archive = stack.dup
+      stack.clear
+    end
 
-      (Math.atan2(x, y) * (180 / Math::PI)).round(0).to_i
+    def elapsed(token)
+      Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) - token[:start]
     end
 
-    def direction(index=0)
-      return nil unless swiped?
+    def within(threshold)
+      move = stack.last
+      down = stack[-2]
 
-      pos = position(index)
-      lpos = last_position(index)
+      t1 = (move[:x] - down[:x]).abs
+      t2 = (move[:y] - down[:y]).abs
 
-      x = position.x - last_position.x
-      y = position.y - last_position.y
+      t1 < threshold && t2 < threshold
+    end
 
-      if x.abs > y.abs
-        # swiping left/right
-        position.x > last_position.x ? :right : :left
-      else
-        # swiping up/down
-        position.y > last_position.y ? :up : :down
-      end
+    def pop
+      stack.pop
     end
 
-    def last_touches
-      @raw[:last_touch_positions].read_array_of_type(LibHokusai::HmlDoubleVec2, :read_pointer, touch_len)
+    def push(type, finger, x, y)
+      log("push: #{type}")
+      stack << {
+        type: type,
+        i: finger,
+        x: x,
+        y: y,
+        start: Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+      }
     end
 
-    def touches
-      @raw[:touch_positions].read_array_of_type(LibHokusai::HmlDoubleVec2, :read_pointer, touch_len)
+    def index
+      token&.[](:finger)
     end
 
-    def initialize(raw)
-      @raw = raw
+    def type
+      token&.[](:type)
+    end
+
+    def token
+      @stack.last
     end
   end
 
   class Input
-    attr_reader :raw
+    attr_accessor :keyboard_override
+    attr_reader :raw, :touch
 
     def hash
       [self.class, mouse.pos.x, mouse.pos.y, mouse.scroll, mouse.left.clicked, mouse.left.down, mouse.left.up].hash
@@ -332,12 +433,14 @@ module Hokusai
 
     def initialize(raw)
       @raw = raw
+      @touch = nil
+      @keyboard_override = false
     end
 
-    def touch
-      return nil if @raw[:touch].null?
+    def support_touch!
+      @touch ||= Touch.new
 
-      Touch.new(@raw)
+      self
     end
 
     def keyboard

data/ui/src/hokusai/util/wrap_stream.rb

@@ -0,0 +1,197 @@
+require "rouge"
+require "hokusai"
+require_relative "./lib/hokusai_code/formatter"
+
+module Hokusai::Util
+  class Wrapped
+    attr_accessor :text, :x, :y, :extra
+    
+    def initialize(text, x, y, extra)
+      @text = text
+      @x = x
+      @y = y
+      @extra = extra
+    end
+  end
+
+  class SelectionWrapper
+    attr_accessor :x, :y, :width, :height
+
+    def initialize(x, y, w, h)
+      @x = x
+      @y = y
+      @width = w
+      @height = h
+    end
+
+    def <<(w)
+      @width += w
+    end
+  end
+
+  class WrapStream
+    attr_accessor :width, :current_width, :x, :y,
+                  :origin_x, :origin_y, :buffer, :stack
+    attr_reader :on_text_cb, :on_text_selection_cb, :on_advancex_cb, :selector, :padding
+
+    def initialize(width, &measure)
+      @width = width
+      @current_width = 0.0
+
+      @origin_x = 0.0
+      @origin_y = 0.0
+      @x = @origin_x
+      @y = @origin_y
+
+      @stack = []
+      @buffer = ""
+
+      @measure_cb = measure
+    end
+
+    def on_advancex(&block)
+      @on_advancex_cb = block
+    end
+
+    def on_text_selection(selector, padding, &block)
+      @selector = selector
+      @padding = padding || Hokusai::Padding.new(0.0, 0.0, 0.0, 0.0)
+      @on_text_selection_cb = block
+    end
+
+    def on_text(&block)
+      @on_text_cb = block
+    end
+
+    def measure(string, extra)
+      @measure_cb.call(string, extra)
+    end
+
+    def flush
+      sx = x + padding.left
+      wrapper = nil
+      stack.each do |(range, extra)|
+        str = buffer[range]
+        if selector
+          str.split("").each do |char|
+            nw, nh = measure(char, extra)
+            ox = on_advancex_cb.call(char.codepoints.first)
+
+            if selector.selected(sx, y + padding.top - selector.offset_y, nw, nh)
+              wrapper ||= SelectionWrapper.new(sx, y + padding.top, 0.0, nh)
+              wrapper << ox
+            end
+
+            sx +=  ox
+          end
+
+          on_text_selection_cb.call(wrapper) if wrapper  
+          wrapper = nil
+        end
+
+        nw, _ = measure(str, extra)
+
+        # hard break on the buffer, split on character
+        wrap_and_call(str, extra)
+
+        self.x += nw
+      end
+      
+      self.current_width = 0.0
+      self.buffer = ""
+      stack.clear
+      self.x = origin_x
+    end
+
+    def wrap(text, extra)
+      offset = 0
+      size = text.size
+
+      stack << [((buffer.size)..(text.size + buffer.size - 1)), extra]
+
+      while offset < size
+        char = text[offset]
+        w, h = measure(char, extra)
+
+        # if it's a newline we want to break
+        if char =~ /\n|\r\n/
+          flush
+
+          stack << [(0...(text.size - offset - 1)), extra]
+          self.y += h
+          self.x = origin_x
+          offset += 1
+
+          next
+        end
+
+        # if adding this char extends beyond the boundary
+        if current_width + w > width
+          # find the last space
+          idx = buffer.rindex(" ")
+          
+          # if there is a break in this line split the buffer
+          # and render the current line
+          unless idx.nil? || idx < (buffer.size / 2)
+            cur = []
+            nex = []
+            found = false
+
+            # We need to split up both the buffer, and the ranges
+            while payload = stack.shift
+              range, xtra = payload
+              if range.include?(idx)
+                # putting the space on this line
+                cur << [(range.begin..idx), xtra]
+                # pp [range, idx]
+                nex << [(0..(range.end - idx - 1)), xtra] unless idx == range.end
+                
+                found = true
+              elsif !found
+                cur << payload
+              else
+                nex << [((range.begin - idx - 1)..(range.end - idx - 1)), xtra] 
+              end
+            end
+
+            scur = buffer[0..idx]
+            snex = buffer[(idx + 1)..-1]
+
+            cur.each do |(range, xtra)|
+              str = scur[range]
+
+              nw, _ = measure(str, xtra)
+              wrap_and_call(str, xtra)
+
+              self.x += nw
+            end
+
+            self.buffer = snex + char
+            self.stack = nex
+            self.y += h
+            self.current_width = measure(buffer, extra).first
+            self.x = origin_x
+          else
+            # break on this word
+            flush
+
+            self.y += h
+            self.current_width = measure(char, extra).first
+            self.buffer = char
+            stack << [(0...(text.size - offset)), extra]
+          end
+        else
+          self.current_width += w
+          buffer << char
+        end
+
+        offset += 1
+      end
+      
+    end
+
+    private def wrap_and_call(text, extra)
+      on_text_cb.call Wrapped.new(text, x, y, extra)
+    end
+  end
+end