window_blessing 0.0.1

data/lib/window_blessing/window.rb

@@ -0,0 +1,273 @@
+module WindowBlessing
+class Window
+  include Tools
+
+  class << self
+    def Window.attr_accessor_with_redraw( *symbols )
+      symbols.each do | symbol |
+        class_eval <<ENDCODE
+        def #{symbol}
+          @#{symbol}
+        end
+
+        def #{symbol}=(value)
+          old_value = @#{symbol}
+          @#{symbol} = value
+          request_redraw_internal if old_value != @#{symbol}
+        end
+ENDCODE
+      end
+    end
+  end
+
+  include Evented
+  attr_accessor :name
+
+  def initialize(area=rect(0,0,20,20))
+    @area = rect
+    @children = []
+    @bg = Buffer.default_bg
+    @fg = Buffer.default_fg
+    @buffer = Buffer.new area.size, :bg => @bg, :fg => @fg
+    self.area = area
+  end
+
+  def inspect
+    "<Window:#{name || object_id} area:#{area.to_s} children:#{children.length}>"
+  end
+
+  # event is in parent-space
+  def pointer_event(event)
+    focus
+    event[:loc] -= area.loc
+    @pointer_focused ||= children.reverse_each.find do |child|
+      child.pointer_inside? event[:loc]
+    end || :background
+    if @pointer_focused==:background
+      handle_event(event)
+    else
+      @pointer_focused.pointer_event event
+    end
+    @pointer_focused = nil if event[:button] == :button_up
+  end
+
+  module KeyboardFocus
+    # keyboard focusing
+    attr_reader :focused_child, :focused
+
+    # for internal use only
+    def focused_child=(child)
+      @focused_child = child
+    end
+
+    def focus
+      return if focused?
+      if parent
+        parent.focus
+        parent_focused_child = parent.focused_child
+        parent_focused_child.blur if parent_focused_child
+        parent.focused_child = self
+      end
+
+      @focused = true
+      handle_event :type => :focus
+    end
+
+    def blur
+      return if blurred?
+      if focused_child
+        focused_child.blur
+        @focused_child = nil
+      end
+
+      @focused = false
+      handle_event :type => :blur
+    end
+
+    def blurred?; !@focused end
+    def focused?; !!@focused end
+
+    def route_keyboard_event(event)
+      if focused_child
+        focused_child.route_keyboard_event event
+      end
+      handle_event event
+    end
+  end
+  include KeyboardFocus
+
+  module Geometry
+    attr_reader :area
+    def area=(area)
+      raise "rectangle area required" unless area.kind_of? GuiGeo::Rectangle
+      raise "size must be at least 1x1" unless area.size > point
+      return if area == @area
+      request_redraw  # request redraw before changing the area
+
+      old_size = @area.size
+      @area = area
+
+      if area.size != old_size
+        resize_buffer old_size
+        children.each {|c| c.handle_event type: :parent_resize, old_size:old_size, size:area.size }
+        handle_event :type => :resize, :old_size => old_size, :size => area.size
+      else
+        # only location changed, request external redraw at the new location
+        request_redraw
+      end
+    end
+
+    def loc; area.loc; end
+    def loc=(new_loc) self.area = rect new_loc, area.size end
+
+    def size; area.size; end
+    def size=(new_size) self.area = rect area.loc, new_size end
+
+    def pointer_inside?(loc) area.contains? loc end
+
+    def move_onscreen
+      return unless parent
+      parent_area = rect(point, parent.area.size)
+      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
+      else
+        @buffer = Buffer.new area.size
+        request_redraw_internal
+      end
+    end
+  end
+  include Geometry
+
+  module ParentsAndChildren
+    attr_reader :parent
+    attr_reader :children
+
+    # returns nil if nothing was done, otherwise returns child
+    def remove_child(child)
+      length_before = children.length
+      @children = children.select {|c| c!=child}
+      if @children.length!=length_before
+        child.request_redraw
+        child.parent= nil
+        child
+      end
+    end
+
+    def add_child(child)
+      children << child
+      child.parent= self
+      child.request_redraw
+      child
+    end
+
+    # for internal use only!
+    def parent=(p)
+      @parent = p
+      handle_event type: :parent_set
+    end
+
+    def each_child(&block)
+      children.each &block
+    end
+
+    def each_child_with_index(&block)
+      children.each_with_index &block
+    end
+
+    def path
+      [parent && parent.path,"#{self.class}#{self.area}"].flatten.compact.join(',')
+    end
+
+    def parent_path
+      parent && parent.path
+    end
+  end
+  include ParentsAndChildren
+
+  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  ")
+    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
+
+      request_redraw @requested_redraw_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))
+    end
+
+    def redraw_requested?; !!requested_redraw_area end
+
+    # Reset @buffer to the designated background. The default implementation resets it to the ' ' character with @bg and @fg colors.
+    #
+    # NOTE: Buffer may have a cropping area set
+    #
+    # NOTE: Safe to override. Calling 'super' is optional. Should fully replace all character, foreground and background colors for @buffer's current croparea.
+    def draw_background
+      buffer.fill :string => ' ', :bg => bg, :fg => fg
+    end
+
+    # Update @buffer
+    #
+    # The default implementation calls #draw_background and then calls #draw on each child.
+    #
+    # 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)
+      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)
+    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
+    end
+  end
+  include Drawing
+end
+end

data/lib/window_blessing/windowed_screen.rb

@@ -0,0 +1,53 @@
+module WindowBlessing
+
+class WindowedScreen < XtermScreen
+  attr_accessor :root_window
+
+  def time(category,info)
+    start = Time.now
+    yield
+    stop = Time.now
+    @total_time ||= 0
+    @draw_count ||= 0
+    @draw_count += 1
+    @total_time += stop - start
+    XtermLog.log "#{category} time = #{((@total_time/@draw_count)*1000).to_i}ms #{info}"
+  end
+
+  def initialize
+    super
+    @root_window = Window.new
+    @root_window.buffer.dirty
+    @root_window.name = "root_window"
+
+    event_manager.add_handler :tick do
+      if redraw_area = root_window.requested_redraw_area
+        time(:redraw, "size=#{redraw_area.size}.area = #{redraw_area.size.x * redraw_area.size.y}") do
+          root_window.draw
+          buffer = root_window.buffer
+          output.draw_buffer buffer.dirty_area.loc, buffer.dirty_subbuffer if buffer.dirty_area
+          buffer.clean
+        end
+      end
+    end
+
+    event_manager.add_handler :key_press do |event|
+      root_window.route_keyboard_event event
+    end
+
+    event_manager.add_handler :string_input do |event|
+      root_window.route_keyboard_event event
+    end
+
+    event_manager.add_handler :resize do |event|
+      root_window.size = event[:size]
+      root_window.request_redraw_internal
+    end
+
+    event_manager.add_handler :pointer do |event|
+      root_window.pointer_event event.clone
+    end
+  end
+
+end
+end

data/lib/window_blessing/xterm_event_parser.rb

@@ -0,0 +1,156 @@
+require "babel_bridge"
+
+module WindowBlessing
+class XtermEventParser < BabelBridge::Parser
+  rule :root, many(:event) do
+    def events
+      event.collect {|e| ev = e.event; ev[:string] ? ev : ev.merge(raw:e.to_s)}
+    end
+  end
+
+  rule :root do # ok to have empty string
+    def events; []; end
+  end
+
+  rule :event, /[^\x00-\x1f\x7F]+/ do
+    def event; {:type => :string_input, :string => to_s} end
+  end
+
+  rule :command, /[a-zA-Z]/
+  rule :number, /[0-9]+/ do
+    def to_i; to_s.to_i; end
+  end
+  rule :numbers, many(:number,";") do
+    def to_a; @array||= number.collect{|n| n.to_i} end
+  end
+
+  rule :event, "\e[8;", :numbers, "t" do
+    include GuiGeo
+    def event
+      {:type => :xterm_state, :state_type => :size, :state => point(*numbers.to_a.reverse)}
+    end
+  end
+
+  rule :event, "\e[4;", :numbers, "t" do
+    include GuiGeo
+    def event
+      {:type => :xterm_state, :state_type => :display_pixel_size, :state => point(*numbers.to_a.reverse)}
+    end
+  end
+
+  rule(:event, "\e\x7F")              {def event;{:type => [:key_press,:backspace], :key => :backspace, :modifiers => [:alt]};end}
+  rule(:event, "\x7F")                {def event;{:type => [:key_press,:backspace], :key => :backspace, :modifiers => []};end}
+  rule(:event, "\e[O")                {def event;{:type => :blur};end}
+  rule(:event, "\e[I")                {def event;{:type => :focus};end}
+
+  rule :event, :key_press do
+    def event; {:type => [:key_press,key], :key => key, :modifiers => modifiers} end
+
+    def modifiers
+      m = key_press.modifier
+      m ? m.modifiers : []
+    end
+  end
+
+  rule(:key_press, "\e", :modifier, "B")  {def key;:down;end}
+  rule(:key_press, "\e", :modifier, "D")  {def key;:left;end}
+  rule(:key_press, "\e", :modifier, "E")  {def key;:begin;end}
+  rule(:key_press, "\e", :modifier, "C")  {def key;:right;end}
+  rule(:key_press, "\e", :modifier, "A")  {def key;:up;end}
+  rule(:key_press, "\e", :modifier, "Z")  {def key;:reverse_tab;end}
+  rule(:key_press, "\e", :modifier, "H")  {def key;:home;end}
+  rule(:key_press, "\e", :modifier, "F")  {def key;:end;end}
+  rule(:key_press, "\e", :modifier, "P")  {def key;:f1;end}
+  rule(:key_press, "\e", :modifier, "Q")  {def key;:f2;end}
+  rule(:key_press, "\e", :modifier, "R")  {def key;:f3;end}
+  rule(:key_press, "\e", :modifier, "S")  {def key;:f4;end}
+  rule(:key_press, "\e", :modifier, "F")  {def key;:home;end}
+  rule(:key_press, "\e", :modifier, "H")  {def key;:end;end}
+
+  rule :modifier, "\e", :modifier do
+    def modifiers
+      (modifier.modifiers || []) + [:alt]
+    end
+
+  end
+  rule :modifier, "[", :numbers do
+    def modifiers
+      {
+      2 => [:shift],
+      3 => [:alt],
+      4 => [:shift, :alt],
+      5 => [:control],
+      6 => [:shift, :control],
+      7 => [:alt, :control],
+      8 => [:shift, :alt, :control],
+      }[numbers.to_a[-1].to_i] || []
+    end
+  end
+
+  rule :modifier, /[\[O]/ do
+    def modifiers; []; end
+  end
+
+  rule :event, "\e[", :number, "~" do
+    def event
+      {
+      :type => :key_press,
+      :key => {
+        3 => :delete,
+        2 => :insert,
+        6 => :page_down,
+        5 => :page_up,
+        13 => :f3,
+        14 => :f4,
+        15 => :f5,
+        17 => :f6,
+        18 => :f7,
+        19 => :f8,
+        20 => :f9,
+        21 => :f10,
+        23 => :f11,
+        24 => :f12,
+        }[number.to_i]
+      }
+    end
+  end
+
+  rule :event, "\e[", "M", match(/.../).as(:state) do
+    def event
+      s, x, y = state.to_s.unpack "CCC"
+      x -= 33
+      y -= 33
+      button_actions = {
+        32 => :button1_down, 33 => :button2_down, 34=> :button3_down, 35=>:button_up,
+        64 => :drag,
+        96 => :wheel_down, 97 => :wheel_up
+      }
+      {
+        type: [:pointer, button_actions[s&99]],
+        button: button_actions[s&99],
+        state: s,
+        loc: point(x,y)
+      }.tap do |h|
+        h[:shift_down] = true if (s&4)!=0
+        h[:alt_down] = true if (s&8)!=0
+        h[:control_down] = true if (s&16)!=0
+      end
+    end
+  end
+
+  # catch-all for unknown xterm escape codes
+  rule :event, /\e\[[^a-zA-Z]*[a-zA-Z]/ do
+    def event
+      {:type => :unknown_xterm_code}
+    end
+  end
+
+  rule :event, /[\x00-\x1f]/ do
+    def event
+      char = "%c"%(to_s.getbyte(0)+"`".getbyte(0))
+      {:type => :key_press, :key => "control_#{char}".to_sym}
+    end
+  end
+
+end
+end