tea 0.6.1

data/doc/example/clip.rb

@@ -0,0 +1,46 @@
+# Test that getting, setting and using the clip rectangle all work.
+# Expected result is a rectangle of smileys, and one at the bottom-right
+# corner.
+
+require 'tea'
+
+puts <<TEST
+You should see a rectangle of smileys, and one in the bottom-right corner,
+for 10 seconds.
+
+Expected output:
+Clip rect is 0, 0, 400, 300
+Clip rect is now 50, 50, 290, 185
+Clip rect is 0, 0, 400, 300 again
+Clip rect is now 368, 268, 32, 32
+
+Actual output:
+TEST
+
+Tea.init
+Tea::Screen.set_mode 400, 300
+
+puts "Clip rect is #{Tea::Screen.clip.join(", ")}"
+
+smiley = Tea::Bitmap.new('smile.png')
+
+Tea::Screen.clip(50, 50, 290, 185) do
+  puts "Clip rect is now #{Tea::Screen.clip.join(", ")}"
+
+  for y in 0..(Tea::Screen.h / smiley.h)
+    for x in 0..(Tea::Screen.w / smiley.w)
+      Tea::Screen.blit smiley, x * smiley.w, y * smiley.h
+    end
+  end
+end
+
+puts "Clip rect is #{Tea::Screen.clip.join(", ")} again"
+
+Tea::Screen.clip Tea::Screen.w - smiley.w, Tea::Screen.h - smiley.h, smiley.w, smiley.h
+Tea::Screen.blit smiley, Tea::Screen.w - smiley.w, Tea::Screen.h - smiley.h
+
+puts "Clip rect is now #{Tea::Screen.clip.join(", ")}"
+
+Tea::Screen.update
+
+sleep 10

data/doc/example/event_app.rb

@@ -0,0 +1,45 @@
+# Test that app events are being picked up.
+# This test is interactive, and should display messages for:
+#
+#  * Gaining and losing mouse focus
+#  * Gaining and losing keyboard focus
+#  * Minimising and restoring the screen window
+#  * App exit
+
+require 'tea'
+
+puts <<TEST
+This is an interactive event test.  It should display messages for:
+
+  * Gaining and losing mouse focus
+  * Gaining and losing keyboard focus
+  * Minimising and restoring the screen window
+  * App exit
+
+Go ahead and start doing things like changing focus.
+
+TEST
+
+Tea.init
+Tea::Screen.set_mode 320, 240
+
+loop do
+  case (e = Tea::Event.get)
+  when Tea::Mouse::Gained
+    puts 'Mouse::Gained event received'
+  when Tea::Mouse::Lost
+    puts 'Mouse::Lost event received'
+  when Tea::Kbd::Gained
+    puts 'Kbd::Gained event received'
+  when Tea::Kbd::Lost
+    puts 'Kbd::Lost event received'
+  when Tea::App::Restored
+    puts 'App::Restored event received'
+  when Tea::App::Minimized
+    puts 'App::Minimized event received'
+  when Tea::App::Exit
+    puts 'App::Exit event received'
+    exit
+  end
+  sleep 0.01
+end

data/doc/example/event_keyboard.rb

@@ -0,0 +1,43 @@
+# Test that keyboard events are being picked up.
+# Expected results are messages responding to key presses.
+
+require 'tea'
+
+puts <<TEST
+You should see a small window.  Try pressing some keys, or Esc to exit.
+TEST
+
+Tea.init
+Tea::Screen.set_mode 320, 240
+
+loop do
+  e = Tea::Event.get(true)
+
+  break if e.class == Tea::App::Exit
+  next unless e.class == Tea::Kbd::Down || e.class == Tea::Kbd::Up
+  break if e.key == Tea::Kbd::ESCAPE
+
+  out = []
+
+  if e.class == Tea::Kbd::Down
+    out << 'down:'
+  else
+    out << '  up:'
+  end
+
+  out << '(' << e.key.to_s << ')'
+
+  if RUBY_VERSION =~ /1\.8/
+    mods = (e.mods.select { |mod, down| down }).map { |pair| pair[0] }
+  else
+    mods = (e.mods.select { |mod, down| down }).keys
+  end
+  out << "++ #{mods.join(' + ')}" if mods.length > 0
+
+  if e.respond_to?(:char)
+    out << '='
+    out << "\"#{e.char}\""
+  end
+
+  puts out.join(' ')
+end

data/doc/example/event_mouse.rb

@@ -0,0 +1,85 @@
+# Test that mouse events are being picked up.
+# Expected output is reporting of mouse move/down/up/scroll events, with
+# position and relevant buttons.
+
+require 'tea'
+
+puts <<TEST
+Move the mouse in the window.  Mouse move/down/up events should be reported,
+with position and relevant buttons.  Mouse wheel scrolling should also be
+picked up, with at least the cursor position.
+TEST
+
+##############################################################################
+
+# We can avoid flooding the terminal with VT100 codes.  Sorry Windows.
+$windows = RUBY_PLATFORM =~ /w(?:in)?32/
+SAVE_POSITION = "\x1b[s"
+RESTORE_POSITION = "\x1b[u"
+HIDE_CURSOR = "\x1b[?25l"
+UNHIDE_CURSOR = "\x1b[?25h"
+CLEAR_TO_LINE_END = "\x1b[K"
+
+# VT100-enhanced printing function that overwrites the current terminal line.
+def pr(*args)
+  print HIDE_CURSOR, SAVE_POSITION if !$windows
+  print *args
+  if $windows
+    puts
+  else
+    print CLEAR_TO_LINE_END, RESTORE_POSITION, UNHIDE_CURSOR
+  end
+end
+
+##############################################################################
+
+Tea.init
+Tea::Screen.set_mode 400, 300
+
+# Event tracking to only put newlines when the event class changes.
+mouse_events = [Tea::Mouse::Move,
+                Tea::Mouse::Down,
+                Tea::Mouse::Up,
+                Tea::Mouse::Scroll]
+handled = false
+last_event_class = Tea::Mouse::Move
+
+# Track repeated scrolling in the same direction.
+scroll_pos = 0
+
+loop do
+  e = Tea::Event.get(true)
+
+  if e.class == Tea::App::Exit
+    puts
+    break
+  end
+
+  # Put a newline when the event class changes.
+  if handled && mouse_events.include?(e.class) && e.class != last_event_class
+    puts
+    last_event_class = e.class
+    scroll_pos = 0
+  end
+
+  handled = true
+  case e
+  when Tea::Mouse::Move
+    if RUBY_VERSION =~ /1\.8/
+      buttons = (e.buttons.select { |button, down| down }).map { |pair| pair[0] }
+    else
+      buttons = (e.buttons.select { |button, down| down }).keys
+    end
+    pr "mouse move : x = #{e.x}, y = #{e.y}, buttons = #{buttons.join(',')}"
+  when Tea::Mouse::Down
+    pr "mouse down : x = #{e.x}, y = #{e.y}, button = #{e.button}"
+  when Tea::Mouse::Up
+    pr "mouse up   : x = #{e.x}, y = #{e.y}, button = #{e.button}"
+  when Tea::Mouse::Scroll
+    dir = e.delta == 1 ? 'down' : 'up  '
+    scroll_pos += e.delta
+    pr "scroll #{dir}: x = #{e.x}, y = #{e.y}, position = #{scroll_pos} (#{e.delta})"
+  else
+    handled = false
+  end
+end

data/doc/example/font_hello.rb

@@ -0,0 +1,22 @@
+# This tests that fonts can be loaded, rendered and drawn.
+# Expected result: 'hello' in a small window for 5 seconds.
+
+require 'tea'
+
+puts <<TEST
+You should see 'hello' in a small window for 5 seconds.
+TEST
+
+Tea.init
+Tea::Screen.set_mode 320, 240
+
+font = Tea::Font.new('font.bmp', Tea::Font::BITMAP_FONT, :transparent_color => Tea::Color::MAGENTA)
+message = 'hello'
+
+x = (Tea::Screen.w - font.string_w(message)) / 2
+y = (Tea::Screen.h - font.h) / 2
+font.draw_to Tea::Screen, x, y, message
+
+Tea::Screen.update
+
+sleep 5

data/doc/example/font_word_wrap.rb

@@ -0,0 +1,44 @@
+# Test that word-wrapping works.
+
+require 'tea'
+
+puts <<TEST
+You should see several lines of bitmapped and SFont text.
+Magenta lines indicate the end of the final lines.
+Press any key to exit.
+TEST
+
+Tea.init
+Tea::Screen.set_mode 400, 300
+
+message = "This is a long line. " +
+          "I hope it's long enough to wrap around. " +
+          "If it wraps, then font word wrapping is working."
+
+font_a = Tea::Font.new('font.bmp', Tea::Font::BITMAP_FONT, :transparent_color => Tea::Color::MAGENTA)
+font_b = Tea::Font.new('sfont.png', Tea::Font::SFONT)
+
+lines_a = font_a.word_wrap(message, Tea::Screen.w)
+lines_b = font_b.word_wrap(message, Tea::Screen.w)
+
+y_pos = 0
+lines_a.each do |line|
+  break if y_pos + font_a.h >= Tea::Screen.h / 2
+  font_a.draw_to Tea::Screen, 0, y_pos, line
+  y_pos += font_a.h
+end
+Tea::Screen.line lines_a.end_x, 0, lines_a.end_x, y_pos, Tea::Color::MAGENTA
+
+old_y_pos = y_pos
+lines_b.each do |line|
+  break if y_pos + font_b.h >= Tea::Screen.h
+  font_b.draw_to Tea::Screen, 0, y_pos, line
+  y_pos += font_b.h
+end
+Tea::Screen.line lines_b.end_x, old_y_pos, lines_b.end_x, y_pos, Tea::Color::MAGENTA
+
+Tea::Screen.update
+
+begin
+  e = Tea::Event.get(true)
+end until e.class == Tea::App::Exit || e.class == Tea::Kbd::Down

data/doc/example/grab.rb

@@ -0,0 +1,28 @@
+# Test that grabbing from bitmaps works.
+# Expected results are a smiley on the screen, but with its quarters swapped.
+
+require 'tea'
+
+puts <<TEST
+You should see a smiley in the centre of the screen for 5 seconds, but with its
+quarters swapped.
+TEST
+
+Tea.init
+Tea::Screen.set_mode 320, 240
+
+smiley = Tea::Bitmap.new("smile.png")
+sw2 = smiley.w / 2
+sh2 = smiley.h / 2
+top_left     = smiley.grab(  0,   0, sw2, sh2)
+top_right    = smiley.grab(sw2,   0, sw2, sh2)
+bottom_left  = smiley.grab(  0, sh2, sw2, sh2)
+bottom_right = smiley.grab(sw2, sh2, sw2, sh2)
+
+Tea::Screen.blit bottom_right, Tea::Screen.w / 2 - sw2, Tea::Screen.h / 2 - sh2
+Tea::Screen.blit bottom_left,        Tea::Screen.w / 2, Tea::Screen.h / 2 - sh2
+Tea::Screen.blit top_right,    Tea::Screen.w / 2 - sw2,       Tea::Screen.h / 2
+Tea::Screen.blit top_left,           Tea::Screen.w / 2,       Tea::Screen.h / 2
+Tea::Screen.update
+
+sleep 5

data/doc/example/init.rb

@@ -0,0 +1,10 @@
+# Test if Tea can initialise.
+# Expected result is nothing.
+
+require 'tea'
+
+puts <<TEST
+This line should be the only output of this test.
+TEST
+
+Tea.init

data/doc/example/lines.rb

@@ -0,0 +1,49 @@
+# Test that lines of various colours can be drawn.
+# Expected results are a 400x300 for 5 seconds with:
+#
+# * 3 vertical lines on the left:         red, green, blue
+# * 3 horizontal lines at the top-right:  yellow, magenta, cyan
+# * 2 diagonal lines at the bottom-right: white and grey
+#
+# The white line should be antialiased.
+
+require 'tea'
+
+puts <<TEST
+You should see a 400x300 window for 5 seconds with:
+
+ * 3 vertical lines on the left:         red, green, blue
+ * 3 horizontal lines at the top-right:  yellow, magenta, cyan
+ * 2 diagonal lines at the bottom-right: white and grey
+
+The white line should be antialiased.
+TEST
+
+Tea.init
+Tea::Screen.set_mode 400, 300
+
+grid_x = Tea::Screen.w / 10
+grid_y = Tea::Screen.h / 10
+
+lines = [[1,   1,   1,   9, Tea::Color::RED],
+         [2,   1,   2,   9, Tea::Color::GREEN],
+         [3,   1,   3,   9, Tea::Color::BLUE],
+         [6,   1,   9,   1, Tea::Color::YELLOW],
+         [6,   2,   9,   2, Tea::Color::MAGENTA],
+         [6,   3,   9,   3, Tea::Color::CYAN],
+         [6,   9,   9,   6, Tea::Color::DARK_GRAY]]
+
+lines.each do |line|
+  Tea::Screen.line grid_x * line[0], grid_y * line[1],
+                    grid_x * line[2], grid_y * line[3],
+                    line[4]
+end
+
+Tea::Screen.line grid_x * 6, grid_y * 6,
+                  grid_x * 9, grid_y * 9,
+                  Tea::Color::WHITE,
+                  :antialias => true
+
+Tea::Screen.update
+
+sleep 5

data/doc/example/lines_aa.rb

@@ -0,0 +1,44 @@
+# Test that anti-aliased lines work as expected.
+# Anti-aliased lines in replace mode should just overwrite the RGBA of the
+# pixels it affects.  In blend mode, the line RGB and destination RGB should be
+# blended according to their ratio, while the final alpha should be the sum of
+# the line and destination alpha values.
+
+require 'tea'
+
+puts <<TEST
+You should see 16 green lines in a wheel, with a green dot in the center,
+against a grey square.
+
+Press any key to exit.
+TEST
+
+Tea.init
+Tea::Screen.set_mode 400, 300
+
+b = Tea::Bitmap.new(250, 250, Tea::Color.mix(0, 0, 0, 0))
+CENTER_X = b.w / 2
+CENTER_Y = b.h / 2
+LINE_CENTER_CLEARANCE = 10
+LINE_LENGTH = 100
+LINE_COLOR = Tea::Color.mix(0, 255, 0, 128)
+SPOKES = 16
+
+Tea::Screen.rect 150, 100, 100, 100, Tea::Color.mix(64, 64, 64)
+
+b.line CENTER_X, CENTER_Y, CENTER_X, CENTER_Y, LINE_COLOR, :antialias => true, :mix => :replace
+
+SPOKES.times do |n|
+  angle = n * Math::PI * 2 / SPOKES
+  x1 = CENTER_X +  LINE_CENTER_CLEARANCE                * Math.cos(angle)
+  y1 = CENTER_Y +  LINE_CENTER_CLEARANCE                * Math.sin(angle)
+  x2 = CENTER_X + (LINE_CENTER_CLEARANCE + LINE_LENGTH) * Math.cos(angle)
+  y2 = CENTER_Y + (LINE_CENTER_CLEARANCE + LINE_LENGTH) * Math.sin(angle)
+  b.line x1, y1, x2, y2, LINE_COLOR, :antialias => true, :mix => n.even? ? :blend : :replace
+end
+
+Tea::Screen.blit b, (Tea::Screen.w - b.w) / 2, (Tea::Screen.h - b.h) / 2
+Tea::Screen.update
+begin
+  e = Tea::Event.get(true)
+end until e.class == Tea::App::Exit || e.class == Tea::Kbd::Down

data/doc/example/lines_alpha.rb

@@ -0,0 +1,33 @@
+# Test that line alpha mixes properly.
+# Expected results:
+#
+# * half-red background
+# * green line, translucent
+# * blue line, translucent
+# * white line, solid
+
+require 'tea'
+
+puts <<TEST
+You should see for 5 seconds:
+
+ * half-red background
+ * green line, translucent
+ * blue line, translucent
+ * white line, solid
+TEST
+
+Tea.init
+Tea::Screen.set_mode 400, 300
+
+tl_green = Tea::Color.mix(  0, 255,   0, 128)
+tl_blue  = Tea::Color.mix(  0,   0, 255, 128)
+tl_white = Tea::Color.mix(255, 255, 255, 128)
+
+Tea::Screen.rect 200, 0, 200, 300, Tea::Color::RED
+20.times { |n| Tea::Screen.line 10,  10 + n, 390,  10 + n, tl_green }
+20.times { |n| Tea::Screen.line 10, 100 + n, 390, 100 + n, tl_blue, :mix => :blend }
+20.times { |n| Tea::Screen.line 10, 200 + n, 390, 200 + n, tl_white, :mix => :replace }
+
+Tea::Screen.update
+sleep 5