shoes-swt 4.0.0.pre2

data/lib/shoes/swt/text_block.rb

@@ -0,0 +1,124 @@
+class Shoes
+  module Swt
+    class TextBlock
+      include Common::Remove
+      include Common::Visibility
+      include Common::Clickable
+      include ::Shoes::BackendDimensionsDelegations
+
+      DEFAULT_SPACING = 4
+
+      attr_reader :dsl, :app
+      attr_accessor :segments
+
+      def initialize(dsl, app)
+        @dsl            = dsl
+        @app            = app
+        @segments       = []
+        @painter        = Painter.new @dsl
+        @app.add_paint_listener @painter
+      end
+
+      def dispose
+        dispose_existing_segments
+      end
+
+      # has a painter, nothing to do
+      def update_position
+      end
+
+      def in_bounds?(x, y)
+        segments.any? do |segment|
+          segment.in_bounds?(x, y)
+        end
+      end
+
+      def contents_alignment(current_position)
+        dispose_existing_segments
+        @segments = Fitter.new(self, current_position).fit_it_in
+
+        set_absolutes_on_dsl(current_position)
+        set_calculated_sizes
+      end
+
+      def adjust_current_position(current_position)
+        last_segment = segments.last
+        current_position.y = @dsl.absolute_bottom
+        current_position.y -= last_segment.last_line_height unless @bumped_to_next_line
+      end
+
+      def set_absolutes_on_dsl(current_position)
+        if segments.one?
+          set_absolutes(@dsl.absolute_left, @dsl.absolute_top)
+        else
+          set_absolutes(@dsl.parent.absolute_left, current_position.next_line_start)
+        end
+
+        if trailing_newline?
+          bump_absolutes_to_next_line
+        else
+          @bumped_to_next_line = false
+        end
+      end
+
+      def set_absolutes(starting_left, starting_top)
+        last_segment = segments.last
+
+        @dsl.absolute_right  = starting_left + last_segment.last_line_width +
+                               margin_right
+
+        @dsl.absolute_bottom = starting_top + last_segment.height +
+                               margin_top + margin_bottom
+      end
+
+      def bump_absolutes_to_next_line
+        @dsl.absolute_right = @dsl.parent.absolute_left
+        @bumped_to_next_line = true
+      end
+
+      def set_calculated_sizes
+        @dsl.calculated_width  = segments.last.width
+        @dsl.calculated_height = segments.inject(0) do |total, segment|
+          total += segment.bounds.height
+        end
+      end
+
+      def remove
+        super
+        clear_contents
+      end
+
+      def replace(*_)
+        clear_contents
+      end
+
+      private
+
+      def clear_contents
+        dispose_existing_segments
+        clear_links
+      end
+
+      def clear_links
+        @dsl.links.each(&:remove)
+      end
+
+      def dispose_existing_segments
+        @segments.map(&:dispose)
+        @segments.clear
+      end
+
+      def trailing_newline?
+        @dsl.text.end_with?("\n")
+      end
+    end
+
+    class Banner < TextBlock; end
+    class Title < TextBlock; end
+    class Subtitle < TextBlock; end
+    class Tagline < TextBlock; end
+    class Caption < TextBlock; end
+    class Para < TextBlock; end
+    class Inscription < TextBlock; end
+  end
+end

data/lib/shoes/swt/text_block/centered_text_segment.rb

@@ -0,0 +1,22 @@
+class Shoes
+  module Swt
+    class TextBlock
+      # Presently centering always takes the whole line, so this class easily
+      # allows us to keep those alternate overrides separate from the main
+      # flowing text definitions for a segment.
+      class CenteredTextSegment < TextSegment
+        def initialize(dsl, width)
+          super(dsl, dsl.text, width)
+
+          # Centered text always takes all the width it's given
+          layout.width = width
+        end
+
+        # Overrides to not allow for flowing on final line--whole width only
+        def last_line_width
+          layout.width
+        end
+      end
+    end
+  end
+end

data/lib/shoes/swt/text_block/cursor_painter.rb

@@ -0,0 +1,53 @@
+class Shoes
+  module Swt
+    class TextBlock
+      class CursorPainter
+        def initialize(text_block_dsl, collection)
+          @text_block_dsl = text_block_dsl
+          @collection = collection
+        end
+
+        def draw
+          if @text_block_dsl.cursor
+            draw_textcursor
+          else
+            remove_textcursor
+          end
+        end
+
+        def draw_textcursor
+          segment = @collection.segment_at_text_position(@text_block_dsl.cursor)
+          relative_cursor = @collection.relative_text_position(@text_block_dsl.cursor)
+          position = segment.get_location(relative_cursor)
+
+          move_if_necessary(segment.element_left + position.x,
+                            segment.element_top + position.y)
+
+        end
+
+        # It's important to only move when necessary to avoid constant redraws
+        def move_if_necessary(x, y)
+          unless textcursor.left == x && textcursor.top == y
+            move_textcursor(x, y)
+          end
+        end
+
+        def move_textcursor(x, y)
+          textcursor.move(x, y)
+          textcursor.show
+        end
+
+        def textcursor
+          @text_block_dsl.textcursor @collection.cursor_height
+        end
+
+        def remove_textcursor
+          return unless @text_block_dsl.has_textcursor?
+
+          @text_block_dsl.textcursor.remove
+          @text_block_dsl.textcursor = nil
+        end
+      end
+    end
+  end
+end

data/lib/shoes/swt/text_block/fitter.rb

@@ -0,0 +1,212 @@
+class Shoes
+  module Swt
+    class TextBlock
+      class Fitter
+        attr_reader :parent
+
+        def initialize(text_block, current_position)
+          @text_block = text_block
+          @dsl = @text_block.dsl
+          @parent = @dsl.parent
+          @current_position = current_position
+        end
+
+        # Fitting text works by using either 1 or 2 layouts
+        #
+        # If the text fits in the height and width available, we use one layout.
+        #
+        # --------------------------
+        # | button | text layout 1 |
+        # --------------------------
+        #
+        # If if the text doesn't fit into that space, then we'll break it into
+        # two different layouts.
+        #
+        # --------------------------
+        # | button | text layout 1 |
+        # --------------------------
+        # | text layout 2 goes here|
+        # | in space               |
+        # --------------------------
+        #           ^
+        #
+        # If there wasn't any available space in the first layout (very narrow)
+        # then we'll make an empty first layout and flow to the second:
+        #
+        # --------------------------
+        # | big big big big button||  < empty layout 1 still present
+        # --------------------------
+        # | text layout 2 goes here|
+        # | in space               |
+        # --------------------------
+        #           ^
+        #
+        # When flowing, the position for the next element gets set to the end of
+        # the text in the second layout (shown as ^ in the diagram).
+        #
+        # Stacks properly move to the next whole line as you'd expect.
+        #
+        def fit_it_in
+          width, height = available_space
+          if @dsl.centered?
+            fit_as_centered(width, height)
+          elsif no_space_in_first_layout?(width)
+            fit_as_empty_first_layout(height)
+          else
+            fit_into_full_layouts(width, height)
+          end
+        end
+
+        def no_space_in_first_layout?(width)
+          width <= 0
+        end
+
+        def fits_in_one_layout?(layout, height)
+          return true if height == :unbounded || layout.line_count == 1
+          layout.bounds.height <= height
+        end
+
+        def fit_into_full_layouts(width, height)
+          layout = generate_layout(width, @dsl.text)
+          if fits_in_one_layout?(layout, height)
+            fit_as_one_layout(layout)
+          else
+            fit_as_two_layouts(layout, height, width)
+          end
+        end
+
+        def fit_as_one_layout(layout)
+          [layout.position_at(@dsl.element_left, @dsl.element_top)]
+        end
+
+        def fit_as_two_layouts(layout, height, width)
+          first_text, second_text = split_text(layout, height)
+
+          # Since we regenerate layouts, we must dispose of first try here.
+          layout.dispose
+          layout = nil
+
+          first_layout = generate_layout(width, first_text)
+
+          if second_text.empty?
+            fit_as_one_layout(first_layout)
+          else
+            generate_two_layouts(first_layout, first_text, second_text, height)
+          end
+        end
+
+        def fit_as_empty_first_layout(height)
+          height += ::Shoes::Slot::NEXT_ELEMENT_OFFSET
+          generate_two_layouts(empty_segment, "", @dsl.text, height)
+        end
+
+        def fit_as_centered(width, height)
+          if first_element_on_line?
+            segment = CenteredTextSegment.new(@dsl, width)
+            [segment.position_at(@dsl.element_left, @dsl.element_top)]
+          else
+            position_two_segments(
+              empty_segment,
+              CenteredTextSegment.new(@dsl, @dsl.containing_width),
+              "",
+              height)
+          end
+        end
+
+        def first_element_on_line?
+          @dsl.left - @dsl.margin_left <= 0
+        end
+
+        def generate_two_layouts(first_layout, first_text, second_text, height)
+          second_layout = generate_second_layout(second_text)
+          position_two_segments(first_layout, second_layout, first_text, height)
+        end
+
+        def generate_second_layout(second_text)
+          generate_layout(@dsl.containing_width, second_text)
+        end
+
+        def position_two_segments(first_layout, second_layout, first_text, height)
+          first_height = first_height(first_layout, first_text, height)
+
+          [
+            first_layout.position_at(@dsl.element_left,
+                                     @dsl.element_top),
+            second_layout.position_at(parent.absolute_left + @dsl.margin_left,
+                                      @dsl.element_top + first_height + 1)
+          ]
+        end
+
+        def available_space
+          width = @dsl.desired_width
+          height = next_line_start - @dsl.absolute_top - 1
+
+          if on_new_line?
+            height = :unbounded
+
+            # Try to find a parent container we fit in.
+            # If that doesn't work, just bail with [0,0] so we don't crash.
+            width = width_from_ancestor if width <= 0
+            return [0, 0] if width < 0
+          end
+
+          [width, height]
+        end
+
+        # If we're positioned outside our containing width, look up the parent
+        # chain until we find a width that accomodates us.
+        def width_from_ancestor
+          width = -1
+          current_ancestor = @dsl.parent
+          until width > 0 || current_ancestor.nil?
+            width = @dsl.desired_width(current_ancestor.width)
+
+            break unless current_ancestor.respond_to?(:parent)
+            current_ancestor = current_ancestor.parent
+          end
+          width
+        end
+
+        def next_line_start
+          @current_position.next_line_start
+        end
+
+        def on_new_line?
+          next_line_start <= @dsl.absolute_top
+        end
+
+        def generate_layout(width, text)
+          TextSegment.new(@dsl, text, width)
+        end
+
+        def empty_segment
+          segment = generate_layout(1, @dsl.text)
+          segment.text = ""
+          segment
+        end
+
+        def split_text(layout, height)
+          ending_offset = 0
+          height_so_far = 0
+
+          offsets = layout.line_offsets
+          offsets[0...-1].each_with_index do |_, i|
+            height_so_far += layout.line_bounds(i).height
+            break if height_so_far > height
+
+            ending_offset = offsets[i+1]
+          end
+          [layout.text[0...ending_offset], layout.text[ending_offset..-1]]
+        end
+
+        # If first text is empty, height may be smaller than an actual line in
+        # the current font. Take our pre-existing allowed height instead.
+        def first_height(first_layout, first_text, height)
+          first_height = first_layout.bounds.height - first_layout.spacing
+          first_height = height if first_text.empty? && height != :unbounded
+          first_height
+        end
+      end
+    end
+  end
+end

data/lib/shoes/swt/text_block/painter.rb

@@ -0,0 +1,47 @@
+class Shoes
+  module Swt
+    class TextBlock
+      class Painter
+        include ::Swt::Events::PaintListener
+        include Common::Resource
+
+        attr_reader :app
+        def initialize(dsl)
+          @dsl = dsl
+          @style = @dsl.style
+          @app = @dsl.app.gui
+        end
+
+        def paintControl(paint_event)
+          reset_graphics_context(paint_event.gc)
+          return if @dsl.hidden?
+
+          draw_layouts(paint_event.gc)
+        end
+
+        def draw_layouts(graphic_context)
+          layouts = TextSegmentCollection.new(@dsl,
+                                              @dsl.gui.segments,
+                                              default_text_styles)
+          layouts.paint_control(graphic_context)
+        end
+
+        private
+
+        def default_text_styles
+          {
+            :fg          => @style[:fg],
+            :bg          => @style[:bg],
+            :strikecolor => @style[:strikecolor],
+            :undercolor  => @style[:undercolor],
+            :font_detail => {
+            :name   => @dsl.font,
+            :size   => @dsl.size,
+            :styles => [::Swt::SWT::NORMAL]
+          }
+          }
+        end
+      end
+    end
+  end
+end