window_blessing 0.0.1 → 0.0.4

data/CHANGELOG.md

@@ -0,0 +1,30 @@
+### vXXX
+
+Improvement
+
+ * Track more than one redraw area. Two small redraw areas no longer become one large one.
+
+Added
+
+ * EventedVariable#before_filter
+ * :fg and :bg options to Buffer#normalize
+ * EventManager#on_event_exception
+ * EventManager#on_every_event
+ * EventManager#on_unhandled_event
+ * simplified keyboard event modifier encoding (shift/alt/control)
+ * fixed keyboard modifiers for pageup/down/home/end & f5-f10
+
+Removed  
+
+ * redraw time log
+ 
+Changed Events
+
+ * Escape: [:key_press, :escape]
+ * Enter: [:key_press, :enter]
+ * Tab: [:key_press, :tab]
+ * Control-Letter: [:kre_press, :[letter]]
+
+### v0.0.2, 2013-02-17
+
+  BugFixes

data/README.md

@@ -1,6 +1,6 @@
 # WindowBlessing
 
-Forget Curses! Try Blessings instead! WindowBlessing is an evented windowing framework for terminal apps.
+Forget curses. Try blessings instead. WindowBlessing is an evented windowing framework for terminal apps.
 
 ## Installation
 

data/bin/buffered_screen_demo.rb

@@ -46,7 +46,7 @@ WindowBlessing::BufferedScreen.new.start(:full=>true) do |screen|
   r.size = demo_buffer.size
   old_r = r.clone
 
-  screen.event_manager.add_handler :tick do |event|
+  screen.event_manager.on :tick do |event|
     if r != old_r
       r = rect(point(0,1), screen.state.size-point(0,1)).bound(r)
       if r != old_r
@@ -57,7 +57,7 @@ WindowBlessing::BufferedScreen.new.start(:full=>true) do |screen|
     end
   end
 
-  screen.event_manager.add_handler :characters do |event|
+  screen.event_manager.on :characters do |event|
     case event[:raw]
     when " " then
       demo_buffer = demo_buffer == grayb ? colorb : grayb
@@ -65,7 +65,7 @@ WindowBlessing::BufferedScreen.new.start(:full=>true) do |screen|
     end
   end
 
-  screen.event_manager.add_handler :key_press do |event|
+  screen.event_manager.on :key_press do |event|
     WindowBlessing::XtermLog.log "key_press: #{event[:key]}"
     case event[:key]
     when :home      then r.loc.x = 0
@@ -85,7 +85,7 @@ WindowBlessing::BufferedScreen.new.start(:full=>true) do |screen|
     screen.screen_buffer.draw_buffer r.loc, demo_buffer
   end
 
-  screen.event_manager.add_handler :pointer do |event|
+  screen.event_manager.on :pointer do |event|
     WindowBlessing::XtermLog.log "mouse: drag #{event[:loc]}"
     r.loc = event[:loc] - demo_buffer.size/2
   end

data/bin/color_picker_demo.rb

@@ -22,6 +22,7 @@ class FadeSlider < Slider
     end
     buffer.bg_buffer = size.y.times.collect {line.clone}
     buffer.fill :string => " ", :fg => value > 0.5 ? Color.black : Color.white
+    draw_handle
   end
 end
 

data/bin/windowed_screen_demo.rb

@@ -11,7 +11,7 @@ class DragWindow < Window
   def initialize(loc,buffer)
     super rect(loc,buffer.size)
     @buffer.draw_buffer point, buffer
-    clean
+    clear_redraw_areas
 
     on :key_press do |event|
       XtermLog.log "key_press: #{event[:key]}"

data/bin/xterm_screen_demo.rb

@@ -2,13 +2,14 @@
 require File.expand_path File.join(File.dirname(__FILE__), %w{.. lib window_blessing})
 include GuiGeo
 
-WindowBlessing::XtermScreen.new.start(:full=>true) do |screen|
+module WindowBlessing
+XtermScreen.new.start(:full=>true) do |screen|
   event_manager = screen.event_manager
 
   last_event = nil
   event_count = 0
 
-  event_manager.add_handler :tick do
+  event_manager.on :tick do
     screen.output.instance_eval do
       cursor(0,0)
       reset_color
@@ -25,9 +26,10 @@ WindowBlessing::XtermScreen.new.start(:full=>true) do |screen|
     end
   end
 
-  event_manager.add_handler do |event|
+  event_manager.on do |event|
     event_count += 1
-    WindowBlessing::XtermLog.log "last_event = #{event.inspect}"
     last_event = event
+    XtermLog.log "#{last_event.inspect}.should == parse(#{(last_event[:raw]||last_event[:string]).inspect})"
   end
 end
+end

data/lib/window_blessing.rb

@@ -11,8 +11,8 @@ See README for licence information.
 
 %w{
   constants
-  color
   tools
+  color
   buffer
   version
   event_queue
@@ -26,6 +26,7 @@ See README for licence information.
   xterm_input
   xterm_screen
   buffered_screen
+  window_redraw_areas
   window
   windowed_screen
   widgets/draggable_background
@@ -37,7 +38,6 @@ See README for licence information.
 end
 
 module WindowBlessing
-  # Your code goes here...
 class << self
   include Tools
   def main(&block)

data/lib/window_blessing/buffer.rb

@@ -66,14 +66,22 @@ class Buffer
     @contents[range] = @contents[range].collect {|l| l.gsub(/[\x00-\x1f]/,'?')}
   end
 
-  def normalize(range=0..-1)
+  # options
+  #   :fg - color
+  #   :bg - color
+  def normalize(range=0..-1, options={})
+    ranged_size = size.clone
+    ranged_size.y = range_length(range) || size.y
     @contents||=[]
     @fg_buffer||=[]
     @bg_buffer||=[]
-    @contents  = @contents.gsub(/[\x00-\x09\x11-\x1f]/,'?').split("\n") if @contents.kind_of?(String)
-    @contents[range]  = resize2d @contents[range] , size, " "
-    @fg_buffer[range] = resize2d @fg_buffer[range], size, Buffer.default_fg
-    @bg_buffer[range] = resize2d @bg_buffer[range], size, Buffer.default_bg
+    if @contents.kind_of?(String)
+      @contents = @contents.split("\n")
+      sanitize_contents
+    end
+    @contents[range]  = resize2d @contents[range] , ranged_size, " "
+    @fg_buffer[range] = resize2d @fg_buffer[range], ranged_size, options[:fg] || Buffer.default_fg
+    @bg_buffer[range] = resize2d @bg_buffer[range], ranged_size, options[:bg] || Buffer.default_bg
   end
 
   def on_dirty(&block)
@@ -176,6 +184,8 @@ class Buffer
     fg = fg.to_screen_color if fg.kind_of?(Color)
     bg = bg.to_screen_color if bg.kind_of?(Color)
 
+    return if area.size==point
+
     if area != internal_area
       @contents  = overlay2d(area.loc, gen_array2d(area.size, string), contents)  if string
       @fg_buffer = overlay2d(area.loc, gen_array2d(area.size, fg),     fg_buffer) if fg
@@ -196,7 +206,7 @@ class Buffer
   end
 
   def draw_buffer(loc, buffer, source_area = nil)
-    source_area = (source_area || buffer.internal_area) | (crop_area - loc)
+    source_area = buffer.internal_area | source_area | (crop_area - loc)
     return unless source_area.present?
 
     unless source_area == buffer.internal_area

data/lib/window_blessing/buffered_screen.rb

@@ -7,11 +7,11 @@ class BufferedScreen < XtermScreen
     super
     @screen_buffer = Buffer.new point(20,20)
 
-    event_manager.add_handler :tick do
+    event_manager.on :tick do
       update_from_screen_buffer
     end
 
-    event_manager.add_handler :resize do |event|
+    event_manager.on :resize do |event|
       @screen_buffer = Buffer.new event[:size]
       @screen_buffer.dirty
     end

data/lib/window_blessing/color.rb

@@ -1,5 +1,6 @@
 module WindowBlessing
 class Color < Struct.new(:r, :g, :b)
+  include Tools
   class <<self
 
     def black;  Color.new(0) end

data/lib/window_blessing/debug_tools/log_request_redraw_internal.rb

@@ -0,0 +1,16 @@
+module WindowBlessing
+module DebugTools
+module LogRequestRedrawInternal
+
+  # sometimes you want to know where redraw requests are coming from
+  # Since request_redraw_internal is recursive, you don't want to log the stack trace with every call - just the first one
+  # This will log a stack-trace once per call
+  def log_request_redraw_internal
+    trace = Kernel.caller
+    return if trace.count {|line| line["request_redraw_internal"]} > 1
+    log "request_redraw_internal trace @requested_redraw_area=#{@requested_redraw_area} path:#{path}\n  "+ trace.join("\n  ")
+  end
+
+end
+end
+end

data/lib/window_blessing/event_manager.rb

@@ -1,13 +1,13 @@
 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.
+# 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 on.
 # 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.
+#   () => 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:
@@ -20,23 +20,28 @@ class EventManager
   def initialize(parent)
     @parent = parent
     @event_handlers = {}
-    add_handler(:event_exception) do |e|
+
+    init_standard_handlers
+  end
+
+  def init_standard_handlers
+    on(: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(){}
+    on(){}
   end
 
   def inspect
     "<#{self.class} :parent => #{parent.inspect} :handled_events => #{event_handlers.keys}>"
   end
 
-  def add_handler(*event_type, &block)
+  def on(*event_type, &block)
     event_handlers[event_type] ||= []
     event_handlers[event_type] << block
   end
 
-  def add_last_handler(*event_type, &block)
+  def on_last(*event_type, &block)
     event_handlers[event_type] = [block] + (event_handlers[event_type] || [])
   end
 

data/lib/window_blessing/evented.rb

@@ -6,7 +6,7 @@ module Evented
 
   # define event handler
   def on(*args,&block)
-    event_manager.add_handler *args, &block
+    event_manager.on *args, &block
     self
   end
 

data/lib/window_blessing/evented_variable.rb

@@ -15,11 +15,18 @@ module WindowBlessing
 # both :change and :refresh events only fire if the value actually changed
 class EventedVariable
   include Evented
+  include Tools
 
   def initialize(value)
     @value = value
   end
 
+  # set a block to be called to processes the set value
+  # block should return the processed value
+  def before_filter(&block)
+    @before_filter = block
+  end
+
   def inspect
     "<#{self.class}:#{object_id} value:#{@value.inspect}>"
   end
@@ -27,9 +34,10 @@ class EventedVariable
   def get; clone_value(@value) end
 
   # update the value & trigger :change and :refresh events
+  # returns the old value
   def set(value)
     old_value = refresh(value)
-    handle_event :type => :change, :old_value => old_value, :value => value if old_value != value
+    handle_event :type => :change, :old_value => old_value, :value => @value if old_value != @value
     old_value
   end
 
@@ -37,6 +45,7 @@ class EventedVariable
   # 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)
+    value = @before_filter.call(value,@value) if @before_filter
     old_value = @value
     @value = value
     handle_event :type => :refresh, :old_value => old_value, :value => value if old_value != value

data/lib/window_blessing/tools.rb

@@ -18,7 +18,7 @@ module Tools
 
   def clone_value(v)
     case v
-    when Fixnum, Bignum, Float then v
+    when Fixnum, Bignum, Float, NilClass then v
     else v.clone
     end
   end
@@ -120,5 +120,15 @@ module Tools
   def color(*args); WindowBlessing::Color.new *args end
   def window(*args); WindowBlessing::Window.new *args end
   def buffer(*args); WindowBlessing::Buffer.new *args end
+
+  def range_length(range)
+    if (range.last < 0 && range.first >=0) || (range.last >=0 && range.first < 0) # length depends on the string or array the range is applied to
+      nil
+    else
+      l = range.last - range.first
+      l += 1 unless range.exclude_end?
+      l
+    end
+  end
 end
 end

data/lib/window_blessing/version.rb

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

data/lib/window_blessing/widgets/draggable_background.rb

@@ -4,7 +4,7 @@ module DraggableBackground
 
   def initialize(*args)
     super *args
-    on :pointer, :button1_down do |event| @mouse_offset = event[:loc] end
+    on :pointer, :button_down  do |event| @mouse_offset = event[:loc] end
     on :pointer, :drag         do |event| self.loc += event[:loc] - @mouse_offset end
   end
 

data/lib/window_blessing/widgets/label.rb

@@ -13,7 +13,7 @@ class Label < WindowBlessing::Window
 
   def pointer_inside?(loc) false; end
 
-  def draw_internal
+  def draw_background
     buffer.contents = text
     buffer.fill :fg => fg, :bg => bg
   end

data/lib/window_blessing/widgets/slider.rb

@@ -39,9 +39,17 @@ class Slider < WindowBlessing::Window
     end
   end
 
-  def draw_internal
+  def handle_area
+    rect(point(handle_x,0),point(1,1))
+  end
+
+  def draw_handle
+    buffer.fill :area => handle_area, :string => "+"
+  end
+
+  def draw_background
     super
-    buffer.fill :area => rect(point(handle_x,0),point(1,1)), :string => "+"
+    draw_handle
   end
 
   def handle_x;           (value * screen_value_range).to_i end

data/lib/window_blessing/widgets/text_field.rb

@@ -80,7 +80,7 @@ class TextField < WindowBlessing::Window
   def text; evented_value.get end
   def text=(t); evented_value.set(t) if !validator || t[validator] end
 
-  def draw_internal
+  def draw_background
     @cursor_pos = bound(0, @cursor_pos, text.length)
     buffer.contents = text
     buffer.fill :fg => fg, :bg => bg

data/lib/window_blessing/window.rb

@@ -37,18 +37,22 @@ ENDCODE
   end
 
   # event is in parent-space
-  def pointer_event(event)
+  def route_pointer_event(event)
     focus
+    event = event.clone
     event[:loc] -= area.loc
+
     @pointer_focused ||= children.reverse_each.find do |child|
       child.pointer_inside? event[:loc]
     end || :background
-    if @pointer_focused==:background
+
+    if @pointer_focused == :background
       handle_event(event)
     else
-      @pointer_focused.pointer_event event
+      @pointer_focused.route_pointer_event event
     end
-    @pointer_focused = nil if event[:button] == :button_up
+
+    @pointer_focused = nil if event[:type][1] == :button_up
   end
 
   module KeyboardFocus
@@ -117,6 +121,8 @@ ENDCODE
       end
     end
 
+    def internal_area; rect @area.size end
+
     def loc; area.loc; end
     def loc=(new_loc) self.area = rect new_loc, area.size end
 
@@ -131,11 +137,8 @@ ENDCODE
       self.area = parent_area.bound(area)
     end
 
-    def internal_area; rect(@area.size); end
-
     private
     def resize_buffer(old_size)
-      @requested_redraw_area = internal_area | @requested_redraw_area if @requested_redraw_area
       if area.size <= old_size
         @buffer = @buffer.subbuffer(rect(area.size))
         request_redraw
@@ -184,7 +187,7 @@ ENDCODE
     end
 
     def path
-      [parent && parent.path,"#{self.class}#{self.area}"].flatten.compact.join(',')
+      [parent && parent.path,"#{self.class}#{self.area}#{":"+name if name}"].flatten.compact.join(',')
     end
 
     def parent_path
@@ -195,32 +198,36 @@ ENDCODE
 
   module Drawing
     Window.attr_accessor_with_redraw :bg, :fg
-    attr_reader :requested_redraw_area, :buffer
-
-    # sometimes you want to know where redraw requests are coming from
-    # Since request_redraw_internal is recursive, you don't want to log the stack trace with every call - just the first one
-    # This will log a stack-trace once per call
-    def log_request_redraw_internal
-      trace = Kernel.caller
-      return if trace.count {|line| line["request_redraw_internal"]} > 1
-      log "request_redraw_internal trace @requested_redraw_area=#{@requested_redraw_area} path:#{path}\n  "+ trace.join("\n  ")
+    attr_reader :redraw_areas, :buffer
+
+    def redraw_areas
+      (@redraw_areas && @redraw_areas.areas || [])
     end
 
-    def request_redraw_internal(area = internal_area)
-      #return if @requested_redraw_area && @requested_redraw_area.contains?(area) - the color_picker demo's info label fails to update with this uncommented - why?
-      @requested_redraw_area = internal_area | (area & @requested_redraw_area)
-      #log_request_redraw_internal
+    def add_redraw_area(area)
+      area = area | internal_area
+      (@redraw_areas ||= WindowRedrawAreas.new) << area
+      area
+    end
 
-      request_redraw @requested_redraw_area
+    # return redraw_areas after clearing it (returns [] if none)
+    def clear_redraw_areas
+      ret = redraw_areas
+      @redraw_areas = nil
+      ret
+    end
+
+    def request_redraw_internal(area = internal_area)
+      request_redraw add_redraw_area(area)
     end
 
     # ask the parent to redraw all, or, if area is set, some of the area covered by this window
     def request_redraw(redraw_area = nil)
       redraw_area ||= internal_area
-      parent && parent.request_redraw_internal(rect(redraw_area.loc + @area.loc, redraw_area.size))
+      parent && parent.request_redraw_internal(redraw_area + loc)
     end
 
-    def redraw_requested?; !!requested_redraw_area end
+    def redraw_requested?; redraw_areas.length > 0 end
 
     # Reset @buffer to the designated background. The default implementation resets it to the ' ' character with @bg and @fg colors.
     #
@@ -238,34 +245,30 @@ ENDCODE
     # NOTE: Buffer may have a cropping area set
     #
     # NOTE: Safe to override. Calling 'super' is optional.
-    def draw_internal
-      draw_background
-      children.each do |child|
-        child.draw buffer, (buffer.crop_area - child.loc)
+    def draw_internal(area = nil)
+      buffer.cropped(area) do
+        draw_background
+        children.each do |child|
+          child.draw buffer, buffer.crop_area - child.loc
+        end
       end
     end
 
-    # marks "redrawn_area" of @buffer "up to date" (redraw no longer required)
-    def clean(redrawn_area = @requested_redraw_area)
-      @requested_redraw_area = nil if redrawn_area && redrawn_area.contains?(@requested_redraw_area)
+    # perform the request redraws
+    # return the areas redrawn (returns [] if none)
+    def redraw
+      clear_redraw_areas.each {|area| draw_internal area}
     end
 
     # Draw the window:
     #
-    # 1) Draw the specified internal_area, or @requested_redraw_area by default, into @buffer
-    # 2) Draw @buffer to target_buffer (if set)
-    # 3) returns the internal_area that was updated
-    def draw(target_buffer = nil, internal_area = @requested_redraw_area)
-      internal_area = self.internal_area | internal_area
-
-      if internal_area.overlaps? @requested_redraw_area
-        buffer.cropped(internal_area | @requested_redraw_area) {draw_internal}
-        clean internal_area
-      end
-
-      target_buffer.draw_buffer(loc, buffer, internal_area) if target_buffer
-
-      internal_area
+    # 1) Draw all requested internal redraw areas, and clear all requests.
+    # 2) Draw @buffer to target_buffer. Optionally, only draw the specified internal_area.
+    # 3) return an array of internal areas redrawn
+    def draw(target_buffer = nil, internal_area = self.internal_area)
+      ret = redraw
+      target_buffer.draw_buffer loc, buffer, internal_area if target_buffer
+      ret
     end
   end
   include Drawing