window_blessing 0.0.1

data/lib/window_blessing/constants.rb

@@ -0,0 +1,3 @@
+module WindowBlessing
+  SMALLEST_FLOAT_DELTA = 0.000000001
+end

data/lib/window_blessing/event_manager.rb

@@ -0,0 +1,75 @@
+module WindowBlessing
+
+# Event handlers are procs which have one input: the event.
+# There can be more than one handler per event-type. Handlers for the same event type are called in the reverse of the order they were added with add_handler.
+# Event handlers return a true value if they handled the event and no more handlers should be called.
+#
+# Events are hashs. The :type field is a symbol specifying the event type. Other key/values are event-specific
+#
+# Special handlers:
+#   :all => gets all (real) events. Returning true will NOT stop event processing.
+#       All gets access to the events first - and can alter them
+#       All does NOT get :tick events
+#   :unhandled_event => if the event has no handler, this handler is used instead. New event looks like this:
+#       :type => :unhandled_event, :event => unhandled_event.clone
+#   :event_exception => if an exception escaped the event handler, a new event is handed to this handler. New event looks like this:
+#       :type => :event_exception, :event => original_event.clone, :exception => exception_caught, :handler => handler_that_threw_error
+class EventManager
+  attr_accessor :event_handlers, :parent
+
+  def initialize(parent)
+    @parent = parent
+    @event_handlers = {}
+    add_handler(:event_exception) do |e|
+      XtermLog.log "#{self.class}(parent=#{parent.inspect}): event_exception: #{e[:exception].inspect} event: #{e[:event].inspect}"
+      XtermLog.log "  "+ e[:exception].backtrace.join("\n  ")
+    end
+    add_handler(){}
+  end
+
+  def inspect
+    "<#{self.class} :parent => #{parent.inspect} :handled_events => #{event_handlers.keys}>"
+  end
+
+  def add_handler(*event_type, &block)
+    event_handlers[event_type] ||= []
+    event_handlers[event_type] << block
+  end
+
+  def add_last_handler(*event_type, &block)
+    event_handlers[event_type] = [block] + (event_handlers[event_type] || [])
+  end
+
+  def send_to_each_handler(handlers, event)
+    return if !handlers && event[:type] == :unhandled_event
+    return handle_event :type => :unhandled_event, :event => event.clone unless handlers
+
+    handlers.reverse_each do |handler|
+      begin
+        handler.call event
+      rescue Exception => e
+        if event[:type] != :event_exception
+          handle_event :type => :event_exception, :event => event.clone, :exception => e, :handler => handler
+        else
+          XtermLog.log "exception in :event_exception handler: #{e.inspect}"
+        end
+        false
+      end
+    end
+  end
+
+  def handle_event(event)
+    type = event[:type]
+    type = [type] unless type.kind_of?(Array)
+
+    type.length.times.reverse_each do |l|
+      send_to_each_handler(event_handlers[type[0..l]], event)
+    end
+    send_to_each_handler(event_handlers[[]], event) unless type == [:tick] || type == [:unhandled_event]
+  end
+
+  def handle_events(events)
+    events.each {|event| handle_event(event)}
+  end
+end
+end

data/lib/window_blessing/event_queue.rb

@@ -0,0 +1,20 @@
+module WindowBlessing
+class EventQueue
+  attr_accessor :queue
+
+  def initialize
+    @queue = []
+  end
+
+  def <<(a)
+    case a
+    when Array then @queue += a
+    else @queue << a
+    end
+  end
+
+  def clear; @queue = [] end
+  def pop_all; @queue.tap {clear} end
+  def empty?; @queue.length == 0 end
+end
+end

data/lib/window_blessing/evented.rb

@@ -0,0 +1,19 @@
+module WindowBlessing
+module Evented
+  def event_manager
+    @event_manager ||= EventManager.new(self)
+  end
+
+  # define event handler
+  def on(*args,&block)
+    event_manager.add_handler *args, &block
+    self
+  end
+
+  def handle_event(event)
+    event[:object] = self
+    event_manager.handle_event(event)
+  end
+
+end
+end

data/lib/window_blessing/evented_variable.rb

@@ -0,0 +1,47 @@
+module WindowBlessing
+
+# There are two events to subscribe to on evented variables:
+#
+# on :change
+#   Subscribe if you need to update the Model when the value changes
+#   NOTE: a :refresh event is fired before every :change event
+#   Ex: if the user change a Slider, this event is fired allowing you to respond to that change
+#
+# on :refresh
+#   Subscribe if you only need to update the View when the value changes
+#   Ex: Sliders subscribe to :refresh to update their view when the value changes
+#       If you want to update the position of the slider, but not trigger any :change events, call .refresh(value)
+#
+# both :change and :refresh events only fire if the value actually changed
+class EventedVariable
+  include Evented
+
+  def initialize(value)
+    @value = value
+  end
+
+  def inspect
+    "<#{self.class}:#{object_id} value:#{@value.inspect}>"
+  end
+
+  def get; clone_value(@value) end
+
+  # update the value & trigger :change and :refresh events
+  def set(value)
+    old_value = refresh(value)
+    handle_event :type => :change, :old_value => old_value, :value => value if old_value != value
+    old_value
+  end
+
+  # update the value & only trigger :refresh events
+  # subscribe to :refresh events if you need to know when the value changes, but you shouldn't change any model-state because of it
+  # if you are changing model-state, subscribe to :change
+  def refresh(value)
+    old_value = @value
+    @value = value
+    handle_event :type => :refresh, :old_value => old_value, :value => value if old_value != value
+    old_value
+  end
+
+end
+end

data/lib/window_blessing/tools.rb

@@ -0,0 +1,124 @@
+require "gui_geometry"
+
+module WindowBlessing
+module Tools
+  include GuiGeo::Tools
+
+  # returns pos, span
+  # on return, pos is within 0..length and pos + span.length is <= length
+  def overlapping_span(pos, span, length)
+    if pos <= -span.length || pos >= length || length <= 0
+      return length, span.class.new
+    elsif pos < 0
+      span = span[-pos..-1]
+      pos = 0
+    end
+    return pos, span[0..(length - pos - 1)]
+  end
+
+  def clone_value(v)
+    case v
+    when Fixnum, Bignum, Float then v
+    else v.clone
+    end
+  end
+
+  # if the block is provided, yields the source elements and the target elements they are overlaying, in order, one at a time
+  def overlay_span(pos, source_span, target_span, &block)
+    pos, span = overlapping_span pos, source_span, target_span.length
+
+    return target_span if span.length == 0
+
+    if block
+      span = span.each_with_index.collect {|s,i| yield s, target_span[i+pos]}
+    end
+
+    if pos == 0
+      span + target_span[span.length..-1]
+    else
+      target_span[0..pos-1] + span + target_span[pos + span.length..-1]
+    end
+  end
+
+  def overlay2d(loc, source, target)
+    overlay_span(loc.y, source, target) do |s, t|
+      overlay_span loc.x, s, t
+    end
+  end
+
+  def resize2d(array2d, size, blank_element)
+    array2d ||= []
+    blank_element = [blank_element] unless blank_element.kind_of?(String)
+
+    if array2d.length != size.y
+      array2d = array2d[0..(size.y-1)]
+      blank_line = blank_element * size.x
+      array2d += (size.y - array2d.length).times.collect {blank_line.clone}
+    end
+
+    array2d.collect do |line|
+      if line.length!=size.x
+        line = line[0..(size.x-1)]
+        line + blank_element * (size.x - line.length)
+      else
+        line
+      end
+    end
+  end
+
+
+  def subarray2d(array2d, area)
+    size = point(array2d[0].length,array2d.length)
+    area = area | rect(size)
+    x_range = area.x_range
+    array2d[area.y_range].collect do |line|
+      line[x_range]
+    end
+  end
+
+  def fill_line(fill, length)
+    line = fill * (length/fill.length)
+    line = (line+fill)[0..length-1] if line.length != length
+    line
+  end
+
+  def gen_array2d(size, fill)
+    fill = case fill
+    when String, Array then fill
+    else [fill]
+    end
+
+    a = (size.x * size.y)
+    full = fill * ((a / fill.length) + 1)
+
+    if fill.kind_of?(String)
+      full.scan /.{#{size.x}}/
+    else
+      full.each_slice(size.x).collect {|a|a}
+    end[0..size.y-1]
+
+  end
+
+
+  # r, g, b are in 0..1
+  def rgb_screen_color(r, g, b)
+    return gray_screen_color(r) if r==g && g==b
+    16 + (r*5.9).to_i * 36 + (g*5.9).to_i * 6 + (b*5.9).to_i
+  end
+
+  # g is in 0..1
+  def gray_screen_color(g)
+    g = (g*24.9).to_i
+    case g
+    when 0 then 0
+    when 24 then 15
+    else 232 + g
+    end
+  end
+
+  def log(str); XtermLog.log "#{self.inspect}: #{str}" end
+  def color(*args); WindowBlessing::Color.new *args end
+  def window(*args); WindowBlessing::Window.new *args end
+  def buffer(*args); WindowBlessing::Buffer.new *args end
+end
+end

data/lib/window_blessing/version.rb

@@ -0,0 +1,3 @@
+module WindowBlessing
+  VERSION = "0.0.1"
+end

data/lib/window_blessing/widgets/draggable_background.rb

@@ -0,0 +1,13 @@
+module WindowBlessing
+module Widgets
+module DraggableBackground
+
+  def initialize(*args)
+    super *args
+    on :pointer, :button1_down do |event| @mouse_offset = event[:loc] end
+    on :pointer, :drag         do |event| self.loc += event[:loc] - @mouse_offset end
+  end
+
+end
+end
+end

data/lib/window_blessing/widgets/label.rb

@@ -0,0 +1,23 @@
+module WindowBlessing
+module Widgets
+class Label < WindowBlessing::Window
+  attr_accessor_with_redraw :text, :fg, :bg
+
+  def initialize(rect, text, fill_options={})
+    super rect
+    @text = text
+    @fg = fill_options[:fg]
+    @bg = fill_options[:bg]
+    request_redraw_internal
+  end
+
+  def pointer_inside?(loc) false; end
+
+  def draw_internal
+    buffer.contents = text
+    buffer.fill :fg => fg, :bg => bg
+  end
+
+end
+end
+end

data/lib/window_blessing/widgets/slider.rb

@@ -0,0 +1,53 @@
+module WindowBlessing
+module Widgets
+class Slider < WindowBlessing::Window
+  include Evented
+  attr_reader :background, :evented_value
+  attr_accessor :key_press_step
+
+  # options
+  #   :key_press_step => 0.1
+  def initialize(rect, evented_value, options={})
+    rect.size.y = 1
+    super rect
+    @evented_value = evented_value = case evented_value
+    when EventedVariable then evented_value
+    when Float then EventedVariable.new(evented_value)
+    else raise ArgumentError.new "invalid text type #{evented_value.inspect}(#{evented_value.class})"
+    end
+    self.bg = gray_screen_color(0.25)
+    @key_press_step = options[:key_press_step] || 0.1
+
+    on :pointer do |event|
+      x = event[:loc].x
+      evented_value.set bound(0.0, x / screen_value_range, 1.0)
+    end
+
+    evented_value.on :refresh do |event|
+      request_redraw_internal
+    end
+
+    on :key_press do |event|
+      case event[:key]
+      when :home      then self.value = 0
+      when :end       then self.value = 1
+      when :left      then
+        self.value = max(0.0, self.value - @key_press_step) if @key_press_step
+      when :right     then
+        self.value = min(1.0, self.value + @key_press_step) if @key_press_step
+      end
+    end
+  end
+
+  def draw_internal
+    super
+    buffer.fill :area => rect(point(handle_x,0),point(1,1)), :string => "+"
+  end
+
+  def handle_x;           (value * screen_value_range).to_i end
+  def screen_value_range; size.x - 1.0 end
+  def value;              evented_value.get end
+  def value=(v)           evented_value.set(v) end
+end
+end
+end

data/lib/window_blessing/widgets/text_field.rb

@@ -0,0 +1,92 @@
+module WindowBlessing
+module Widgets
+class TextField < WindowBlessing::Window
+  NON_NEGATIVE_INTEGER_VALIDATOR = /^[0-9]*$/
+  attr_accessor_with_redraw :cursor_bg, :cursor_pos
+  attr_accessor :validator
+  attr_accessor :evented_value
+
+  def initialize(rect, evented_value, options={})
+    super rect
+    @evented_value = evented_value = case evented_value
+    when EventedVariable then evented_value
+    when String then EventedVariable.new(evented_value)
+    else raise ArgumentError.new "invalid text type #{evented_value.inspect}(#{evented_value.class})"
+    end
+
+    @validator = options[:validator]
+
+    @fg = options[:fg] || Color.gray
+    @bg = options[:bg] || Color.black
+    @cursor_bg = options[:cursor_bg] || (@fg + @bg) / 2
+    @cursor_pos = text.length
+    request_redraw_internal
+
+    on :pointer do |event|
+      self.cursor_pos = event[:loc].x
+    end
+
+    evented_value.on :refresh do |event|
+      request_redraw_internal
+    end
+
+    on :string_input do |event|
+      p = cursor_pos
+      s = event[:string]
+
+      self.text = if p==0
+        s + text
+      elsif p==text.length
+        text + s
+      else
+        text[0..p] + s + text[p+1..-1]
+      end
+      self.cursor_pos += s.length
+    end
+
+    on :key_press do |event|
+      case event[:key]
+      when :backspace then
+        if cursor_pos > 0
+          p = cursor_pos
+          before = text
+          self.text = if cursor_pos == 1
+            text[1..-1]
+          elsif cursor_pos == text.length
+            self.text = text[0..-2]
+          else
+            self.text = text[0..p-2] + text[p..-1]
+          end
+          log " before = #{before.inspect} after = #{text.inspect}"
+          self.cursor_pos -= 1
+        end
+
+      when :home      then self.cursor_pos = 0
+      when :end       then self.cursor_pos = text.length
+      when :left      then self.cursor_pos -= 1
+      when :right     then self.cursor_pos += 1
+      end
+    end
+
+    on :focus do
+      request_redraw_internal
+    end
+
+    on :blur do
+      request_redraw_internal
+    end
+  end
+
+  def text; evented_value.get end
+  def text=(t); evented_value.set(t) if !validator || t[validator] end
+
+  def draw_internal
+    @cursor_pos = bound(0, @cursor_pos, text.length)
+    buffer.contents = text
+    buffer.fill :fg => fg, :bg => bg
+    buffer.fill :area => rect(point(cursor_pos,0),point(1,1)), :bg => cursor_bg if focused?
+  end
+
+end
+end
+end