colstrom-fidgit 0.2.7

data/lib/fidgit/elements/scroll_area.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+module Fidgit
+  # A basic scrolling area. It is not managed in any way (use ScrollWindow for that).
+  class ScrollArea < Container
+    # @return [Vertical] The content shown within this ScrollArea
+    attr_reader :content
+
+    def offset_x; x - @content.x; end
+    def offset_y; y - @content.y; end
+
+    def offset_x=(value)
+      @content.x = x - [[@content.width - width, value].min, 0].max
+    end
+
+    def offset_y=(value)
+      @content.y = y - [[@content.height - height, value].min, 0].max
+    end
+
+    # @option options [Number] :offset (0)
+    # @option options [Number] :offset_x (value of :offset option)
+    # @option options [Number] :offset_y (value of :offset option)
+    # @option options [Element] :owner The owner of the content, such as the scroll-window containing the content.
+    def initialize(options = {})
+      options = {
+        offset: 0,
+        owner: nil,
+      }.merge! options
+
+      @owner = options[:owner]
+
+      super(options)
+
+      @content = Vertical.new(parent: self, padding: 0)
+
+      self.offset_x = options[:offset_x] || options[:offset]
+      self.offset_y = options[:offset_y] || options[:offset]
+    end
+
+    def hit_element(x, y)
+      # Only pass on mouse events if they are inside the window.
+      if hit?(x, y)
+        @content.hit_element(x, y) || self
+      else
+        nil
+      end
+    end
+
+    def recalc
+      super
+      # Always recalc our owner if our content resizes, even though our size can't change even if the content changes
+      # (may encourage ScrollWindow to show/hide scroll-bars, for example)
+      @owner.recalc if @owner
+    end
+
+    protected
+    def draw_foreground
+      $window.clip_to(*rect) do
+        @content.draw
+      end
+    end
+
+    protected
+    def post_init_block(&block)
+      with(&block)
+    end
+  end
+end

data/lib/fidgit/elements/scroll_bar.rb

@@ -0,0 +1,128 @@
+# encoding: utf-8
+
+module Fidgit
+  # @abstract
+  class ScrollBar < Composite
+    class Handle < Element
+      event :begin_drag
+      event :update_drag
+      event :end_drag
+
+      def drag?(button); button == :left; end
+
+      def initialize(options = {})
+        super options
+
+        subscribe :begin_drag do |sender, x, y|
+          # Store position of the handle when it starts to drag.
+          @drag_start_pos = [x - self.x, y - self.y]
+        end
+
+        subscribe :update_drag do |sender, x, y|
+          parent.parent.handle_dragged_to x - @drag_start_pos[0], y - @drag_start_pos[1]
+        end
+
+        subscribe :end_drag do
+          @drag_start_pos = nil
+        end
+      end
+    end
+
+    def initialize(options = {})
+      options = {
+        background_color: default(:background_color),
+        border_color: default(:border_color),
+        rail_width: default(:rail_width),
+        rail_color: default(:rail_color),
+        handle_color: default(:handle_color),
+        owner: nil,
+      }.merge! options
+
+      @owner = options[:owner]
+      @rail_thickness = options[:rail_width]
+      @rail_color = options[:rail_color]
+
+      super options
+
+      @handle_container = Container.new(parent: self, width: options[:width], height: options[:height]) do
+        @handle = Handle.new(parent: self, x: x, y: y, background_color: options[:handle_color])
+      end
+
+      subscribe :left_mouse_button do |sender, x, y|
+        clicked_to_move x, y
+      end
+    end
+  end
+
+  class HorizontalScrollBar < ScrollBar
+    attr_reader :owner
+
+    def initialize(options = {})
+      super options
+
+      @handle.height = height
+
+      @handle_container.subscribe :left_mouse_button do |sender, x, y|
+        distance = @owner.view_width
+        @owner.offset_x += (x > @handle.x)? +distance : -distance
+      end
+    end
+
+    def update
+      window = parent.parent
+
+      # Resize and re-locate the handles based on changes to the scroll-window.
+      content_width = window.content_width.to_f
+      @handle.width = (window.view_width * width) / content_width
+      @handle.x = x + (window.offset_x * width) / content_width
+    end
+
+    def draw_foreground
+      draw_rect x + padding_left, y + (height - @rail_thickness) / 2, width, @rail_thickness, z, @rail_color
+      super
+    end
+
+    def handle_dragged_to(x, y)
+      @owner.offset_x = @owner.content_width * ((x - self.x) / width.to_f)
+    end
+
+    def clicked_to_move(x, y)
+      new_x = x < @handle.x ? @handle.x - @handle.width : @handle.x + @handle.width
+      handle_dragged_to new_x, @handle.y
+    end
+  end
+
+  class VerticalScrollBar < ScrollBar
+    def initialize(options = {})
+      super options
+
+      @handle.width = width
+
+      @handle_container.subscribe :left_mouse_button do |sender, x, y|
+        distance = @owner.view_height
+        @owner.offset_y += (y > @handle.y)? +distance : -distance
+      end
+    end
+
+    def update
+      window = parent.parent
+      content_height = window.content_height.to_f
+      @handle.height = (window.view_height * height) / content_height
+      @handle.y = y + (window.offset_y * height) / content_height
+    end
+
+    def draw_foreground
+      draw_rect x + (width - @rail_thickness) / 2, y + padding_top, @rail_thickness, height, z, @rail_color
+      super
+    end
+
+    def handle_dragged_to(x, y)
+      @owner.offset_y = @owner.content_height * ((y - self.y) / height.to_f)
+    end
+
+    def clicked_to_move(x, y)
+      new_y = y < @handle.y ? @handle.y - @handle.height : @handle.y + @handle.height
+      handle_dragged_to @handle.x, new_y
+    end
+  end
+end

data/lib/fidgit/elements/scroll_window.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+module Fidgit
+  class ScrollWindow < Composite
+    def content; @view.content; end
+    def offset_x; @view.offset_x; end
+    def offset_x=(value); @view.offset_x = value; end
+    def offset_y; @view.offset_y; end
+    def offset_y=(value); @view.offset_y = value; end
+
+    def view_width; @view.width; end
+    def view_height; @view.height; end
+    def content_width; @view.content.width; end
+    def content_height; @view.content.height; end
+    def width=(value); super(value); end
+    def height=(value); super(value); end
+
+    def initialize(options = {})
+      options = {
+        scroll_bar_thickness: default(:scroll_bar_thickness),
+      }.merge! options
+
+      super(options)
+
+      @grid = grid num_columns: 2, padding: 0, spacing: 0 do
+        @view = scroll_area(owner: self, width: options[:width], height: options[:height])
+        @spacer = label '', padding: 0, width: 0, height: 0
+      end
+
+      @scroll_bar_v = VerticalScrollBar.new(owner: self, width: options[:scroll_bar_thickness], align_v: :fill)
+      @scroll_bar_h = HorizontalScrollBar.new(owner: self, height: options[:scroll_bar_thickness], align_h: :fill)
+    end
+
+    protected
+    def layout
+      # Prevent recursive layouts.
+      return if @in_layout
+
+      @in_layout = true
+
+      if @view
+        # Constrain the values of the offsets.
+        @view.offset_x = @view.offset_x
+        @view.offset_y = @view.offset_y
+
+        if content_height > view_height
+          unless @scroll_bar_v.parent
+            @view.send(:rect).width -= @scroll_bar_v.width
+            @grid.remove @spacer
+            @grid.insert 1, @scroll_bar_v
+          end
+        else
+          if @scroll_bar_v.parent
+            @view.send(:rect).width += @scroll_bar_v.width
+            @grid.remove @scroll_bar_v
+            @grid.insert 1, @spacer
+          end
+        end
+
+        if content_width > view_width
+          unless @scroll_bar_h.parent
+            @view.send(:rect).height -= @scroll_bar_h.height
+            @grid.add @scroll_bar_h
+          end
+        else
+          if @scroll_bar_h.parent
+            @view.send(:rect).height += @scroll_bar_h.height
+            @grid.remove @scroll_bar_h
+          end
+        end
+      end
+
+      super
+
+      @in_layout = false
+    end
+
+    protected
+    def post_init_block(&block)
+      @view.content.with(&block)
+    end
+  end
+end

data/lib/fidgit/elements/slider.rb

@@ -0,0 +1,125 @@
+# encoding: utf-8
+
+module Fidgit
+  class Slider < Composite
+    # @private
+    class Handle < Element
+      event :begin_drag
+      event :end_drag
+      event :update_drag
+
+      def drag?(button); button == :left; end
+
+      # @param (see Element#initialize)
+      #
+      # @option (see Element#initialize)
+      def initialize(options = {}, &block)
+        options = {
+          background_color: default(:background_color),
+          border_color: default(:border_color),
+        }.merge! options
+
+        super options
+
+        subscribe :begin_drag do |sender, x, y|
+          # Store position of the handle when it starts to drag.
+          @drag_start_pos = [x - self.x, y - self.y]
+        end
+
+        subscribe :update_drag do |sender, x, y|
+          if parent.enabled?
+            parent.handle_dragged_to x - @drag_start_pos[0], y - @drag_start_pos[1]
+          else
+            publish :end_drag
+          end
+        end
+
+        subscribe :end_drag do
+          @drag_start_pos = nil
+        end
+      end
+
+      def tip; parent.tip; end
+    end
+
+    event :changed
+
+    attr_reader :value, :range, :handle
+
+    # @param (see Composite#initialize)
+    #
+    # @option (see Composite#initialize)
+    # @option options [Range] :range (0.0..1.0)
+    # @option options [Range] :value (minimum of :range)
+    def initialize(options = {}, &block)
+      options = {
+        range: 0.0..1.0,
+        height: 25,
+        background_color: default(:background_color),
+        border_color: default(:border_color),
+        groove_color: default(:groove_color),
+        handle_color: default(:handle_color),
+        groove_thickness: 5,
+      }.merge! options
+
+      @range = options[:range].dup
+      @groove_color = options[:groove_color].dup
+      @groove_thickness = options[:groove_thickness]
+      @continuous = @range.min.is_a?(Float) || @range.max.is_a?(Float)
+
+      super(options)
+
+      @handle = Handle.new(parent: self, width: (height / 2 - padding_left), height: height - padding_top + padding_bottom,
+                           background_color: options[:handle_color])
+
+      self.value = options.has_key?(:value) ? options[:value] : @range.min
+    end
+
+    def value=(value)
+      @value = @continuous ? value.to_f : value.round
+      @value = [[@value, @range.min].max, @range.max].min
+      @handle.x = x + padding_left + ((width - @handle.width) * (@value - @range.min) / (@range.max - @range.min).to_f)
+      publish :changed, @value
+
+      @value
+    end
+
+    def tip
+      tip = super
+      tip.empty? ? @value.to_s : "#{tip}: #{@value}"
+    end
+
+    def left_mouse_button(sender, x, y)
+      # In this case, x should be the centre of the handle after it has moved.
+      self.value = ((x - (@handle.width / 2) - self.x) / (width - @handle.width)) * (@range.max - @range.min) + @range.min
+      @mouse_down = true
+
+      nil
+    end
+
+    def handle_dragged_to(x, y)
+      # In this case, x is the left-hand side fo the handle.
+      self.value = ((x - self.x) / (width - @handle.width)) * (@range.max - @range.min) + @range.min
+    end
+
+    protected
+    # Prevent standard packing layout change.
+    def layout
+      nil
+    end
+
+    protected
+    def draw_background
+      super
+      # Draw a groove for the handle to move along.
+      draw_rect x + (@handle.width / 2), y + (height - @groove_thickness) / 2, width - @handle.width, @groove_thickness, z, @groove_color
+      nil
+    end
+
+    protected
+    # Use block as an event handler.
+    def post_init_block(&block)
+      subscribe :changed, &block
+    end
+  end
+end

data/lib/fidgit/elements/text_area.rb

@@ -0,0 +1,494 @@
+# encoding: utf-8
+
+module Fidgit
+  class TextArea < Element
+    ENTITY_PLACEHOLDER = "*"
+    ENTITIES_AND_TAGS_PATTERN = %r%<[a-z](?:=[a-f0-9]+)?>|</[a-z]>|&\w+;%i
+
+    # @return [Number]
+    attr_reader :min_height
+    # @return [Number]
+    attr_reader :max_height
+
+    # @return [Number]
+    attr_reader :line_spacing
+
+    # @param [Boolean] value
+    # @return [Boolean]
+    attr_writer :editable
+
+    # @return [String] Text, but stripped of tags.
+    attr_reader :stripped_text
+
+    event :begin_drag
+    event :update_drag
+    event :end_drag
+
+    event :changed
+    event :focus
+    event :blur
+
+    def drag?(button); button == :left; end
+
+    # Is the area editable? This will always be false if the Element is disabled.
+    def editable?
+      enabled? and @editable
+    end
+
+    # Text within the element.
+    # @return [String]
+    def text
+      @text_input.text.force_encoding 'UTF-8'
+    end
+
+    # Returns the range of the selection.
+    #
+    # @return [Range]
+    def selection_range
+      from = [@text_input.selection_start, caret_position].min
+      to = [@text_input.selection_start, caret_position].max
+
+      (from...to)
+    end
+
+    # Returns the text within the selection.
+    #
+    # @return [String]
+    def selection_text
+      stripped_text[selection_range]
+    end
+
+    # Sets the text within the selection. The caret will be placed at the end of the inserted text.
+    #
+    # @param [String] str Text to insert.
+    # @return [String] The new selection text.
+    def selection_text=(str)
+      from = [@text_input.selection_start, @text_input.caret_pos].min
+      to = [@text_input.selection_start, @text_input.caret_pos].max
+      new_length = str.length
+
+      full_text = text
+      tags_length_before = (0...from).inject(0) {|m, i| m + @tags[i].length }
+      tags_length_inside = (from...to).inject(0) {|m, i| m + @tags[i].length }
+      range = (selection_range.first + tags_length_before)...(selection_range.last + tags_length_before + tags_length_inside)
+      full_text[range] = str.encode('UTF-8', undef: :replace)
+      @text_input.text = full_text
+
+      @text_input.selection_start = @text_input.caret_pos = from + new_length
+
+      recalc # This may roll back the text if it is too long!
+
+      publish :changed, self.text
+
+      str
+    end
+
+    # Position of the caret.
+    #
+    # @return [Integer] Number in range 0..text.length
+    def caret_position
+      @text_input.caret_pos
+    end
+
+    # Position of the caret.
+    #
+    # @param [Integer] pos Position of caret in the text.
+    # @return [Integer] New position of caret.
+    def caret_position=(position)
+      raise ArgumentError, "Caret position must be in the range 0 to the length of the text (inclusive)" unless position.between?(0, stripped_text.length)
+      @text_input.caret_pos = position
+
+      position
+    end
+
+    # Sets caret to the end of the text.
+    #
+    # @param [String] text
+    # @return [String] Current string (may be the old one if passed on was too long).
+    def text=(text)
+      @text_input.text = text
+      recalc # This may roll back the text if it is too long.
+      publish :changed, self.text
+      self.text
+    end
+
+
+    # @param (see Element#initialize)
+    #
+    # @option (see Element#initialize)
+    # @option options [String] :text ("")
+    # @option options [Integer] :height Sets both min and max height at once.
+    # @option options [Integer] :min_height
+    # @option options [Integer] :max_height (Infinite)
+    # @option options [Number] :line_spacing (0)
+    # @option options [Boolean] :editable (true)
+    def initialize(options = {}, &block)
+      options = {
+        text: '',
+        max_height: Float::INFINITY,
+        line_spacing: default(:line_spacing),
+        background_color: default(:background_color),
+        border_color: default(:border_color),
+        caret_color: default(:caret_color),
+        caret_period: default(:caret_period),
+        focused_border_color: default(:focused, :border_color),
+        selection_color: default(:selection_color),
+        editable: true,
+      }.merge! options
+
+      @line_spacing = options[:line_spacing]
+      @caret_color = options[:caret_color].dup
+      @caret_period = options[:caret_period]
+      @focused_border_color = options[:focused_border_color].dup
+      @selection_color = options[:selection_color].dup
+      @editable = options[:editable]
+
+      @lines = [''] # List of lines of wrapped text.
+      @caret_positions = [[0, 0]] # [x, y] of each position the caret can be in.
+      @char_widths = [] # Width of each character in the text.
+      @text_input = Gosu::TextInput.new
+      @old_text = ''
+      @old_caret_position = 0
+      @old_selection_start = 0
+      @tags = Hash.new("") # Hash of tags embedded in the text.
+
+      @text_input.text = options[:text].dup
+      @stripped_text = '' # Text stripped of xml tags.
+
+      super(options)
+
+      min_height = padding_left + padding_right + font.height
+      if options[:height]
+        @max_height = @min_height = [options[:height], min_height].max
+      else
+        @max_height = [options[:max_height], min_height].max
+        @min_height = options[:min_height] ? [options[:min_height], min_height].max : min_height
+      end
+      rect.height = [padding_left + padding_right + font.height, @min_height].max
+
+      subscribe :left_mouse_button, method(:click_in_text)
+      subscribe :right_mouse_button, method(:click_in_text)
+
+      # Handle dragging.
+      subscribe :begin_drag do |sender, x, y|
+        # Store position of the handle when it starts to drag.
+        @drag_start_pos = [x - self.x, y - self.y]
+      end
+
+      subscribe :update_drag do |sender, x, y|
+        index = text_index_at_position(x, y)
+        self.caret_position = [index, @stripped_text.length].min if index
+      end
+
+      subscribe :end_drag do
+        @drag_start_pos = nil
+      end
+    end
+
+    # @return [nil]
+    def click_in_text(sender, x, y)
+      publish :focus unless focused?
+
+      # Move caret to position the user clicks on.
+      index = text_index_at_position x, y
+      self.caret_position = @text_input.selection_start = [index, @stripped_text.length].min if index
+
+      nil
+    end
+
+    # Does the element have the focus?
+    def focused?; @focused; end
+
+    # @return [nil]
+    def focus(sender)
+      @focused = true
+      $window.current_game_state.focus = self
+      $window.text_input = @text_input
+
+      nil
+    end
+
+    # @return [nil]
+    def blur(sender)
+      if focused?
+        $window.current_game_state.focus = nil
+        $window.text_input = nil
+      end
+
+      @focused = false
+
+      nil
+    end
+
+    # Draw the text area.
+    #
+    # @return [nil]
+    def draw_foreground
+      # Always roll back changes made by the user unless the text is editable.
+      if editable? or text == @old_text
+        recalc if focused? # Workaround for Windows draw/update bug.
+        @old_caret_position = caret_position
+        @old_selection_start = @text_input.selection_start
+      else
+        roll_back
+      end
+
+      if caret_position > stripped_text.length
+        self.caret_position = stripped_text.length
+      end
+
+      if @text_input.selection_start >= stripped_text.length
+        @text_input.selection_start = stripped_text.length
+      end
+
+      # Draw the selection.
+      selection_range.each do |pos|
+        char_x, char_y = @caret_positions[pos]
+        char_width = @char_widths[pos]
+        left, top = x + padding_left + char_x, y + padding_top + char_y
+        draw_rect left, top, char_width, font.height, z, @selection_color
+      end
+
+      # Draw text.
+      @lines.each_with_index do |line, index|
+        font.draw(line, x + padding_left, y + padding_top + y_at_line(index), z)
+      end
+
+      # Draw the caret.
+      if focused? and ((Gosu::milliseconds / @caret_period) % 2 == 0)
+        caret_x, caret_y = @caret_positions[caret_position]
+        left, top = x + padding_left + caret_x, y + padding_top + caret_y
+        draw_rect left, top, 1, font.height, z, @caret_color
+      end
+    end
+
+    protected
+    # Index of character in reference to the displayable text.
+    def text_index_at_position(x, y)
+      # Move caret to position the user clicks on.
+      mouse_x, mouse_y = x - (self.x + padding_left), y - (self.y + padding_top)
+      @char_widths.each.with_index do |width, i|
+        char_x, char_y = @caret_positions[i]
+        if mouse_x.between?(char_x, char_x + width) and mouse_y.between?(char_y, char_y + font.height)
+          return i
+        end
+      end
+
+      nil # Didn't find a character at that position.
+    end
+
+    # y position of the
+    protected
+    def y_at_line(lines_number)
+      lines_number * (font.height + line_spacing)
+    end
+
+
+    protected
+    # Helper for #recalc
+    # @return [Integer]
+    def position_letters_in_word(word, line_width)
+      # Strip tags before measuring word.
+      word.gsub(ENTITIES_AND_TAGS_PATTERN, '').each_char do |c|
+        char_width = font.text_width(c)
+        line_width += char_width
+        @caret_positions.push [line_width, y_at_line(@lines.size)]
+        @char_widths.push char_width
+      end
+
+      line_width
+    end
+
+    protected
+    # @return [nil]
+    def layout
+      # Don't need to re-layout if the text hasn't changed.
+      return if @old_text == text
+
+      publish :changed, self.text
+
+      # Save these in case we are too long.
+      old_lines = @lines
+      old_caret_positions = @caret_positions
+      old_char_widths = @char_widths
+
+      @lines = []
+      @caret_positions = [[0, 0]] # Position 0 is before the first character.
+      @char_widths = []
+
+      space_width = font.text_width ' '
+      max_width = width - padding_left - padding_right - space_width
+
+      line = ''
+      line_width = 0
+      word = ''
+      word_width = 0
+
+      strip_tags
+
+      stripped_text.each_char.with_index do |char, i|
+        tag = @tags[i]
+
+        # \x0 is just a place-holder for an entity: &entity;
+        if char == ENTITY_PLACEHOLDER
+          char = tag
+          tag = ""
+        end
+
+        case char
+          when "\n"
+            char_width = 0
+          else
+            char_width = font.text_width char
+        end
+
+        overall_width = line_width + (line_width == 0 ? 0 : space_width) + word_width + char_width
+        if overall_width > max_width and not (char == ' ' and not word.empty?)
+          if line.empty?
+            # The current word is longer than the whole word, so split it.
+            # Go back and set all the character positions we have.
+            position_letters_in_word(word, line_width)
+
+            # Push as much of the current word as possible as a complete line.
+            @lines.push word + tag + (char == ' ' ? '' : '-')
+            line_width = font.text_width(word)
+
+            word = ''
+            word_width = 0
+          else
+
+            # Adding the current word would be too wide, so add the current line and start a new one.
+            @lines.push line
+            line = ''
+          end
+
+          widen_last_character line_width
+          line_width = 0
+        end
+
+        case char
+          when "\n"
+            # A new-line ends the word and puts it on the line.
+            line += word + tag
+            line_width = position_letters_in_word(word, line_width)
+            @caret_positions.push [line_width, y_at_line(@lines.size)]
+            @char_widths.push 0
+            widen_last_character line_width
+            @lines.push line
+            word = ''
+            word_width = 0
+            line = ''
+            line_width = 0
+
+          when ' '
+            # A space ends a word and puts it on the line.
+            line += word + tag + char
+            line_width = position_letters_in_word(word, line_width)
+            line_width += space_width
+            @caret_positions.push [line_width, y_at_line(@lines.size)]
+            @char_widths.push space_width
+
+            word = ''
+            word_width = 0
+
+          else
+            # If there was a previous line and we start a new line, put the caret pos on the current line.
+            if line.empty?
+              @caret_positions[-1] = [0, y_at_line(@lines.size)]
+            end
+
+            # Start building up a new word.
+            word += tag + char
+            word_width += char_width
+        end
+      end
+
+      # Add any remaining word on the last line.
+      unless word.empty?
+        line_width = position_letters_in_word(word, line_width)
+        @char_widths << width - line_width - padding_left - padding_right
+        line += word
+      end
+
+      @lines.push line if @lines.empty? or not line.empty?
+
+      # Roll back if the height is too long.
+      new_height = padding_left + padding_right + y_at_line(@lines.size)
+      if new_height <= max_height
+        @old_text = text
+        rect.height = [new_height, @min_height].max
+        @old_caret_position = caret_position
+        @old_selection_start = @text_input.selection_start
+      else
+        roll_back
+      end
+
+      nil
+    end
+
+    protected
+    def roll_back
+      @text_input.text = @old_text
+      self.caret_position = @old_caret_position
+      @text_input.selection_start = @old_selection_start
+      recalc
+    end
+
+    protected
+    def widen_last_character(line_width)
+      @char_widths[-1] += (width - line_width - padding_left - padding_right) unless @char_widths.empty?
+    end
+
+    public
+    # Cut the selection and copy it to the clipboard.
+    def cut
+      str = selection_text
+      unless str.empty?
+        Clipboard.copy str
+        self.selection_text = '' if editable?
+      end
+    end
+
+    public
+    # Copy the selection to the clipboard.
+    def copy
+      str = selection_text
+      Clipboard.copy str unless str.empty?
+    end
+
+    public
+    # Paste the contents of the clipboard into the TextArea.
+    def paste
+      self.selection_text = Clipboard.paste
+    end
+
+    protected
+    # Use block as an event handler.
+    def post_init_block(&block)
+      subscribe :changed, &block
+    end
+
+    protected
+    # Strip XML tags and entities ("<c=000000></c>" and "&entity;")
+    # @note Entities will mess up the system because we don't know how wide they are.
+    def strip_tags
+      tags_length = 0
+      @tags = Hash.new('')
+
+      @stripped_text = text.gsub(ENTITIES_AND_TAGS_PATTERN) do |tag|
+        pos = $`.length - tags_length
+        tags_length += tag.length
+        @tags[pos] += tag
+
+        # Entities need to have a non-printing character that can represent them.
+        # Still not right, but does mean there are the right number of characters.
+        if tag[0] == '&'
+          tags_length -= 1
+          ENTITY_PLACEHOLDER # Will be expanded later.
+        else
+          '' # Tags don't use up space, so ignore them.
+        end
+      end
+    end
+  end
+end