shoes 4.0.0.pre1 → 4.0.0.pre2

data/lib/shoes/swt/star.rb

@@ -1,51 +0,0 @@
-class Shoes
-  module Swt
-    class Star
-      extend Forwardable
-      include Common::Fill
-      include Common::Stroke
-      include Common::Clickable
-      include Common::PainterUpdatesPosition
-      include Common::Toggle
-      include Common::Clear
-      include ::Shoes::BackendDimensionsDelegations
-
-      def_delegators :dsl, :angle, :outer, :inner, :points
-
-      attr_reader :dsl, :app, :transform, :container
-
-      def initialize(dsl, app, &blk)
-        @dsl = dsl
-        @app = app
-        @container = @app.real
-
-        @painter = Painter.new(self)
-        @app.add_paint_listener @painter
-        clickable blk if blk
-      end
-
-      class Painter < Common::Painter
-        def fill(gc)
-          gc.fillPolygon make_polygon(@obj)
-        end
-
-        def draw(gc)
-          gc.drawPolygon make_polygon(@obj)
-        end
-        
-        def make_polygon(obj)
-          outer, inner, points, left, top = obj.outer, obj.inner, obj.points,
-                                            obj.element_left, obj.element_top
-          polygon = []
-          polygon << left << (top + outer)
-          (1..points*2).each do |i|
-            angle =  i * ::Math::PI / points
-            r = (i % 2 == 0) ? outer : inner
-            polygon << (left + r * ::Math.sin(angle)) << (top + r * ::Math.cos(angle))
-          end
-          polygon
-        end
-      end
-    end
-  end
-end

data/lib/shoes/swt/swt_button.rb

@@ -1,49 +0,0 @@
-class Shoes
-  module Swt
-    class SwtButton
-      include Common::Clear
-      include Common::Toggle
-      include Common::UpdatePosition
-      include ::Shoes::BackendDimensionsDelegations
-
-      attr_reader :parent, :real, :dsl
-
-      def initialize(dsl, parent, type)
-        @dsl = dsl
-        @parent = parent
-
-        @type = type
-        @real = ::Swt::Widgets::Button.new(@parent.real, @type)
-        @real.addSelectionListener { eval_block @dsl.blk } if @dsl.blk
-
-        yield(@real) if block_given?
-
-        set_size
-      end
-
-      def eval_block blk
-        blk.call @dsl
-      end
-
-      def focus
-        @real.set_focus
-      end
-
-      def click &blk
-        @real.addSelectionListener { eval_block blk }
-      end
-
-      def enabled(value)
-        @real.enable_widget value
-      end
-
-      private
-      def set_size
-        @real.pack
-        @dsl.element_width ||= @real.size.x
-        @dsl.element_height ||= @real.size.y
-        @real.setSize @dsl.element_width, @dsl.element_height
-      end
-    end
-  end
-end

data/lib/shoes/swt/text_block.rb

@@ -1,133 +0,0 @@
-class Shoes
-  module Swt
-    class TextBlock
-      include Common::Clear
-      include Common::Toggle
-      include Common::Clickable
-      include ::Shoes::BackendDimensionsDelegations
-
-      DEFAULT_SPACING = 4
-
-      attr_reader :dsl, :app
-      attr_accessor :fitted_layouts
-
-      def initialize(dsl)
-        @dsl            = dsl
-        @app            = dsl.app.gui
-        @opts           = @dsl.opts
-        @fitted_layouts = []
-        @painter        = TextBlockPainter.new @dsl
-        @app.add_paint_listener @painter
-      end
-
-      def dispose
-        dispose_existing_layouts
-      end
-
-      # has a painter, nothing to do
-      def update_position
-      end
-
-      def in_bounds?(x, y)
-        fitted_layouts.any? do |fitted|
-          fitted.in_bounds?(x, y)
-        end
-      end
-
-      def contents_alignment(current_position)
-        dispose_existing_layouts
-        @fitted_layouts = TextBlockFitter.new(self, current_position).fit_it_in
-
-        if fitted_layouts.one?
-          set_absolutes_for_one_layout
-        else
-          set_absolutes_for_two_layouts(current_position.next_line_start)
-        end
-
-        if trailing_newline?
-          bump_absolutes_to_next_line
-        end
-      end
-
-      def first_layout
-        fitted_layouts.first.layout
-      end
-
-      def last_layout
-        fitted_layouts.last.layout
-      end
-
-      def last_bounds
-        line_count = last_layout.line_count
-        last_layout.get_line_bounds(line_count - 1)
-      end
-
-      def layout_height(layout)
-        layout.bounds.height - layout.spacing
-      end
-
-      def line_height(layout)
-        layout.line_metrics(layout.line_count - 1).height
-      end
-
-      def trailing_newline?
-        last_layout.text.end_with?("\n")
-      end
-
-      def set_absolutes_for_one_layout
-        @dsl.absolute_right = @dsl.absolute_left + last_bounds.width + margin_right
-        @dsl.absolute_bottom = @dsl.absolute_top + layout_height(first_layout) +
-                                margin_top + margin_bottom
-        @dsl.absolute_top = @dsl.absolute_bottom - line_height(first_layout)
-        @dsl.calculated_width = first_layout.bounds.width
-      end
-
-      def set_absolutes_for_two_layouts(next_line_start)
-        @dsl.absolute_right =  @dsl.parent.absolute_left + last_bounds.width + margin_right
-        @dsl.absolute_bottom = next_line_start + layout_height(last_layout) +
-                                margin_top + margin_bottom
-        @dsl.absolute_top = @dsl.absolute_bottom - line_height(last_layout)
-        @dsl.calculated_width = last_layout.bounds.width
-      end
-
-      def bump_absolutes_to_next_line
-        @dsl.absolute_right = @dsl.parent.absolute_left
-        @dsl.absolute_top = @dsl.absolute_bottom
-      end
-
-      def clear
-        super
-        clear_contents
-      end
-
-      def replace(*values)
-        clear_contents
-        @dsl.update_text_styles(values)
-      end
-
-      private
-
-      def clear_contents
-        dispose_existing_layouts
-        clear_links
-      end
-
-      def clear_links
-        @dsl.links.each(&:clear)
-      end
-
-      def dispose_existing_layouts
-        @fitted_layouts.map(&:dispose)
-        @fitted_layouts.clear
-      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_cursor_painter.rb

@@ -1,112 +0,0 @@
-class Shoes
-  module Swt
-    class TextBlockCursorPainter
-      def initialize(dsl, fitted_layouts)
-        @dsl = dsl
-        @fitted_layouts = fitted_layouts
-      end
-
-      def draw
-        if @dsl.cursor
-          draw_textcursor
-        else
-          remove_textcursor
-        end
-      end
-
-      def draw_textcursor
-        layout = choose_layout
-        x, y = new_position(layout)
-
-        # It's important to only move when necessary to avoid constant redraws
-        unless textcursor.left == x && textcursor.top == y
-          move_textcursor(x, y)
-        end
-      end
-
-      def new_position(layout)
-        position = layout.get_location(relative_cursor)
-        [layout.element_left + position.x, layout.element_top + position.y]
-      end
-
-      def move_textcursor(x, y)
-        textcursor.move(x, y)
-        textcursor.show
-      end
-
-      def first_layout
-        @fitted_layouts.first
-      end
-
-      def last_layout
-        @fitted_layouts.last
-      end
-
-      # Only works with one or two layouts, but that's what we've got
-      # -1 positions us at the very end, regardless text length
-      def choose_layout
-        if cursor_fits_in_first_layout?
-          first_layout
-        else
-          last_layout
-        end
-      end
-
-      # Again, assumes one or two layout system
-      def relative_cursor
-        if cursor_at_end?
-          relative_cursor_at_end
-        elsif cursor_fits_in_first_layout?
-          relative_cursor_in_first_layout
-        else
-          relative_cursor_in_last_layout
-        end
-      end
-
-      def cursor_fits_in_first_layout?
-        @dsl.cursor <= first_layout.text.length && @dsl.cursor >= 0
-      end
-
-      def cursor_at_end?
-        cursor_negative? || cursor_past_all_text?
-      end
-
-      def cursor_negative?
-        @dsl.cursor < 0
-      end
-
-      def cursor_past_all_text?
-        @dsl.cursor > @dsl.text.length
-      end
-
-      def relative_cursor_at_end
-        last_layout.text.length
-      end
-
-      def relative_cursor_in_first_layout
-        @dsl.cursor
-      end
-
-      def relative_cursor_in_last_layout
-        @dsl.cursor - first_layout.text.length
-      end
-
-      def textcursor
-        @dsl.textcursor cursor_height
-      end
-
-      # This could be smarter, basing height on the actual line the cursor's
-      # in. For now, just use the first line's height.
-      def cursor_height
-        first_layout.layout.get_line_bounds(0).height
-      end
-
-      def remove_textcursor
-        return unless @dsl.has_textcursor?
-
-        @dsl.textcursor.remove
-        @dsl.textcursor = nil
-      end
-    end
-  end
-end

data/lib/shoes/swt/text_block_fitter.rb

@@ -1,180 +0,0 @@
-class Shoes
-  module Swt
-    class TextBlockFitter
-      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 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.get_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)
-        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)
-        # Although we purposefully empty it out, still need the first layout
-        layout = generate_layout(1, @dsl.text)
-        layout.text = ""
-
-        height += ::Shoes::Slot::NEXT_ELEMENT_ON_NEXT_LINE_OFFSET.y
-        generate_two_layouts(layout, "", @dsl.text, height)
-      end
-
-      def generate_two_layouts(first_layout, first_text, second_text, height)
-        first_height = first_height(first_layout, first_text, height)
-        second_layout = generate_second_layout(second_text)
-
-        [
-          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)
-        ]
-      end
-
-      def generate_second_layout(second_text)
-        generate_layout(@dsl.containing_width, second_text)
-      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)
-        FittedTextLayout.new(@dsl, text, width)
-      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_metrics(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.get_bounds.height
-        first_height = height if first_text.empty?
-        first_height
-      end
-    end
-  end
-end