window_blessing 0.0.1

data/bin/windowed_screen_demo.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+require File.expand_path File.join(File.dirname(__FILE__), %w{.. lib window_blessing})
+include GuiGeo
+include WindowBlessing
+include Widgets
+include Tools
+
+class DragWindow < Window
+  include DraggableBackground
+  def initialize(loc,buffer)
+    super rect(loc,buffer.size)
+    @buffer.draw_buffer point, buffer
+    clean
+
+    on :key_press do |event|
+      XtermLog.log "key_press: #{event[:key]}"
+      r = area.clone
+      case event[:key]
+      when :home      then r.loc.x = 0
+      when :page_up   then r.loc.y = 0
+      when :page_down then r.loc.y = parent.size.y
+      when :end       then r.loc.x = parent.size.x
+      when :left      then r.loc.x -= 1
+      when :right     then r.loc.x += 1
+      when :up        then r.loc.y -= 1
+      when :down      then r.loc.y += 1
+      end
+      self.area = r
+      self.move_onscreen
+    end
+  end
+end
+
+def color_window(r)
+  size = r.size
+  DragWindow.new r.loc, (Buffer.new(size).tap do |buffer|
+    size.y.times do |y|
+      size.x.times do |x|
+        c1 = rgb_screen_color y / (size.y-1).to_f, x / (size.x-1).to_f, 0
+        c2 = rgb_screen_color 0, 1 - y / (size.y-1).to_f, 1 - x / (size.x-1).to_f
+        buffer.draw_rect rect(point(x,y),point(1,1)), :bg => c1, :fg => c2, :string => "▒"
+      end
+    end
+  end)
+end
+
+def gray_window(r)
+  size = r.size
+  DragWindow.new r.loc, (Buffer.new(size).tap do |buffer|
+    size.y.times do |y|
+      size.x.times do |x|
+        g1 = gray_screen_color(x / (size.x-1).to_f)
+        g2 = gray_screen_color(y / (size.y-1).to_f)
+        buffer.draw_rect rect(point(x,y),point(1,1)), :bg => g1, :fg => g2, :string => "o"
+      end
+    end
+  end)
+end
+
+WindowedScreen.new.start(:full=>true, :utf8 => true) do |screen|
+
+  root_window = screen.root_window
+
+  root_window.add_child gray_win = gray_window(rect(10,10,25,13))
+  root_window.add_child color_win = color_window(rect(30,15,24,12))
+  root_window.add_child Label.new rect(point,point(1000,1)),
+    " Arrows, Home, End, PgUp, PgDown or drag with Mouse to move. Space to toggle. Ctrl-Q to quit.",
+    :bg => color(0.25)
+
+end

data/bin/xterm_screen_demo.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+require File.expand_path File.join(File.dirname(__FILE__), %w{.. lib window_blessing})
+include GuiGeo
+
+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
+    screen.output.instance_eval do
+      cursor(0,0)
+      reset_color
+      puts Time.now
+      puts "Ctrl-Q to quit"
+      puts "size: #{screen.state.size.inspect}"
+
+      if last_event
+        e = last_event.inspect
+        e += "\nfailure_info (raw=#{last_event[:raw].inspect}): #{last_event[:failure_info]}" if last_event[:failure_info]
+        e += "\ntrace:\n  "+last_event[:exception].backtrace.join("\n  ") if last_event[:type]==:event_exception
+        puts "event #{event_count}: #{e}   "
+      end
+    end
+  end
+
+  event_manager.add_handler do |event|
+    event_count += 1
+    WindowBlessing::XtermLog.log "last_event = #{event.inspect}"
+    last_event = event
+  end
+end

data/lib/window_blessing.rb

@@ -0,0 +1,54 @@
+def add_load_path(path)
+  full_path = File.expand_path path
+  $LOAD_PATH.unshift full_path unless $LOAD_PATH.include?(path) || $LOAD_PATH.include?(full_path)
+end
+add_load_path File.dirname(__FILE__)
+
+=begin
+Copyright 2013 Shane Brinkman-Davis
+See README for licence information.
+=end
+
+%w{
+  constants
+  color
+  tools
+  buffer
+  version
+  event_queue
+  event_manager
+  evented
+  evented_variable
+  xterm_event_parser
+  xterm_log
+  xterm_output
+  xterm_state
+  xterm_input
+  xterm_screen
+  buffered_screen
+  window
+  windowed_screen
+  widgets/draggable_background
+  widgets/label
+  widgets/slider
+  widgets/text_field
+}.each do |file|
+  require "window_blessing/#{file}"
+end
+
+module WindowBlessing
+  # Your code goes here...
+class << self
+  include Tools
+  def main(&block)
+    main_window = Window.new
+    Screen.new.open do
+      instance_exec(main_window, &block)
+      on_tick do
+        main_window.area = rect(screen_buffer.size)
+        main_window.draw screen_buffer
+      end
+    end
+  end
+end
+end

data/lib/window_blessing/buffer.rb

@@ -0,0 +1,216 @@
+=begin
+NOTE: Unlike bitmap graphics, it is often going to be faster to clone bitmap frames rather than do special logic to extract data from frames in-place. This is due the relatively small amount of data for a console-window "buffer" (cols * lines ~= a few kilobytes) and Ruby having optimized routines to handle strings as single units.
+
+For example, it's actually going to be faster to draw a sub-region from one buffer onto another by first copying out the subbuffer from the source buffer and then copying it into the target buffer.
+
+NOTE: I'm just making intelligent guesses here. Haven't actually profiled. It keeps the code simpler, too.
+
+=end
+module WindowBlessing
+class Buffer
+  include Tools
+
+  attr_reader :size
+  attr_accessor :contents
+
+  # used as the default color when resizing
+  attr_accessor :bg, :fg
+
+  # color buffers. 2D arrays. Each element is a number, 0-255.
+  attr_accessor :fg_buffer, :bg_buffer
+
+  attr_accessor :crop_area
+  attr_reader :dirty_area
+
+  def Buffer.default_bg; 0; end
+  def Buffer.default_fg; 7; end
+
+  # init-options
+  #   :bg_bufer => 2D array of 0-255 values
+  #   :fg_bufer => 2D array of 0-255 values
+  #   :contents => array of strings or string with new-lines
+  # fill options (will override init-options)
+  #   :string, :bg, :fg -- see #fill
+  def initialize(size, options={})
+    @size = size
+
+    @contents  = options[:contents]
+    @fg_buffer = options[:fg_buffer]
+    @bg_buffer = options[:bg_buffer]
+
+    fill options
+    normalize
+    clean
+  end
+
+  def each_line(&block)
+    @contents.zip(fg_buffer,bg_buffer).each &block
+  end
+
+  def fg_buffer=(fg_buffer)
+    @fg_buffer = fg_buffer
+    normalize
+  end
+
+  def bg_buffer=(bg_buffer)
+    @bg_buffer = bg_buffer
+    normalize
+  end
+
+  def contents=(contents)
+    @contents = contents
+    normalize
+  end
+
+  def sanitize_contents(range=0..-1)
+    @contents[range] = @contents[range].collect {|l| l.gsub(/[\x00-\x1f]/,'?')}
+  end
+
+  def normalize(range=0..-1)
+    @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
+  end
+
+  def on_dirty(&block)
+    @on_dirty = block
+  end
+
+  def crop_area
+    @crop_area || rect(size)
+  end
+
+  def cropped(area)
+    old_crop_area = @crop_area
+    @crop_area = area | crop_area
+    yield
+    self
+  ensure
+    @crop_area = old_crop_area
+  end
+
+  def cropped?
+    crop_area != rect(size)
+  end
+
+  def inspect
+    "<Buffer size:#{size.inspect}>"
+  end
+
+  def to_s
+    contents.join "\n"
+  end
+
+  def internal_area
+    rect(size)
+  end
+
+  def subbuffer(area)
+    area = internal_area | area
+    return buffer unless area.present?
+
+    x_range = area.x_range
+
+    buffer area.size,
+      :contents  => subarray2d(contents,area),
+      :fg_buffer => subarray2d(fg_buffer,area),
+      :bg_buffer => subarray2d(bg_buffer,area),
+      :fg => fg,
+      :bg => bg
+  end
+
+  def dirty_subbuffer
+    @dirty_area && subbuffer(@dirty_area)
+  end
+
+  #########
+  # dirty?
+  #########
+  def dirty?
+    !!@dirty_area
+  end
+
+  def clean
+    @dirty_area = nil
+  end
+
+  def dirty(area = internal_area)
+    @dirty_area = (area & @dirty_area) | internal_area
+    @on_dirty.call if @on_dirty
+    @dirty_area
+  end
+
+  #########
+  # DRAWING
+  #########
+
+  def clear
+    @contents = @bg_buffer = @fg_buffer = nil
+    normalize
+    self
+  end
+
+  # Fills characters, foreground and/or background buffers with the specified values.
+  #
+  # If one of the buffers is not specified to be filled, it is not changed.
+  #
+  # For example, you can set the foreground color without changing the text:
+  #
+  #   fill :fg => rgb_screen_color(1,0,0)
+  #
+  # options
+  #  :area => Rectangle # only fill the specified area (intersected with the crop_area)
+  #  :bg => background color OR 1d array of bg-color pattern - nil => don't touch bg
+  #  :fg => foreground color OR 1d array of fg-color pattern - nil => don't touch fb
+  #  :string => string - length 1 or more, use to fill-init @contents - nil => don't touch @contents
+  def fill(options = {})
+    area = crop_area
+    area = area | options[:area] if options[:area]
+    string = options[:string]
+    fg = options[:fg]
+    bg = options[:bg]
+    fg = fg.to_screen_color if fg.kind_of?(Color)
+    bg = bg.to_screen_color if bg.kind_of?(Color)
+
+    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
+      @bg_buffer = overlay2d(area.loc, gen_array2d(area.size, bg),     bg_buffer) if bg
+    else
+      @contents  = gen_array2d(size, string) if string
+      @fg_buffer = gen_array2d(size, fg)     if fg
+      @bg_buffer = gen_array2d(size, bg)     if bg
+    end
+    dirty area
+    self
+  end
+
+  # Just like #fill except all buffers are filled. Default values are used if not specified.
+  # options - see #fill options
+  def draw_rect(rectangle, options={})
+    fill({:area => rectangle, :string => " ", :fg => Buffer.default_fg, :bg => Buffer.default_bg}.merge options)
+  end
+
+  def draw_buffer(loc, buffer, source_area = nil)
+    source_area = (source_area || buffer.internal_area) | (crop_area - loc)
+    return unless source_area.present?
+
+    unless source_area == buffer.internal_area
+      loc += source_area.loc
+      buffer = buffer.subbuffer(source_area)
+    end
+
+    @contents  = overlay2d(loc, buffer.contents, contents)
+    @fg_buffer = overlay2d(loc, buffer.fg_buffer, fg_buffer)
+    @bg_buffer = overlay2d(loc, buffer.bg_buffer, bg_buffer)
+
+    dirty rect(loc, buffer.size)
+    self
+  end
+
+end
+end

data/lib/window_blessing/buffered_screen.rb

@@ -0,0 +1,29 @@
+module WindowBlessing
+
+class BufferedScreen < XtermScreen
+  attr_accessor :screen_buffer
+
+  def initialize
+    super
+    @screen_buffer = Buffer.new point(20,20)
+
+    event_manager.add_handler :tick do
+      update_from_screen_buffer
+    end
+
+    event_manager.add_handler :resize do |event|
+      @screen_buffer = Buffer.new event[:size]
+      @screen_buffer.dirty
+    end
+  end
+
+  def update_from_screen_buffer
+    if dirty_buffer = screen_buffer.dirty_subbuffer
+#      XtermLog.log "#{self.class}#update_from_screen_buffer() diry_area: #{screen_buffer.dirty_area}"
+      output.draw_buffer screen_buffer.dirty_area.loc, dirty_buffer
+      screen_buffer.clean
+    end
+  end
+
+end
+end

data/lib/window_blessing/color.rb

@@ -0,0 +1,71 @@
+module WindowBlessing
+class Color < Struct.new(:r, :g, :b)
+  class <<self
+
+    def black;  Color.new(0) end
+    def white;  Color.new(1) end
+    def gray;   Color.new(0.5) end
+
+    def red;    Color.new(1,0,0) end
+    def green;  Color.new(0,1,0) end
+    def blue;   Color.new(0,0,1) end
+
+    def yellow; Color.new(1,1,0) end
+    def cyan;   Color.new(0,1,1) end
+    def magenta;Color.new(1,0,1) end
+  end
+
+  def initialize(r=0.0, g=r, b=r)
+    case r
+    when String then self.hex=r
+    else super r, g, b
+    end
+  end
+
+  def br
+    (r + g + b) / 3.0
+  end
+
+  def hex=(hex)
+    raise "invalid hex color #{hex.inspect}" unless hex[/#?(((..)(..)(..))|((.)(.)(.)))/]
+    self.r = ($3 || ($7*2)).hex/255.0
+    self.g = ($4 || ($8*2)).hex/255.0
+    self.b = ($5 || ($9*2)).hex/255.0
+  end
+
+  def inspect; "color#{self}" end
+  def to_s; "(#{r},#{g},#{b})" end
+  def to_hex; "#%02x%02x%02x"%to_a256 end
+  def to_a256; [r256,g256,b256] end
+  def to_a; [r,g,b] end
+
+  # to xterm pallette color
+  def to_screen_color; rgb_screen_color(r,g,b) end
+
+  def [](i)
+    case i
+    when 0, :r then r
+    when 1, :g then g
+    when 2, :b then b
+    end
+  end
+
+  def []=(key,v)
+    case key
+    when 0, :r then self.r = v
+    when 1, :g then self.g = v
+    when 2, :b then self.b = v
+    end
+  end
+
+  def r256; (r*255).to_i end
+  def g256; (g*255).to_i end
+  def b256; (b*255).to_i end
+
+  def +(v) v.kind_of?(Color) ? Color.new(r + v.r, g + v.g, b + v.b) : Color.new(r + v, g + v, b + v) end
+  def -(v) v.kind_of?(Color) ? Color.new(r - v.r, g - v.g, b - v.b) : Color.new(r - v, g - v, b - v) end
+  def *(v) v.kind_of?(Color) ? Color.new(r * v.r, g * v.g, b * v.b) : Color.new(r * v, g * v, b * v) end
+  def /(v) v.kind_of?(Color) ? Color.new(r / v.r, g / v.g, b / v.b) : Color.new(r / v, g / v, b / v) end
+
+end
+end