hokusai-zero 0.2.6.pre.pinephone6 → 0.2.6

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

@@ -1,193 +0,0 @@
-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