shoes-swt 4.0.0.pre2

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

@@ -0,0 +1,50 @@
+class Shoes
+  module Swt
+    class TextFontFactory
+      def initialize
+        @fonts = []
+      end
+
+      def create_font(font_style)
+        name = font_style[:name]
+        size = font_style[:size]
+        styles = styles_bitmask(font_style[:styles])
+
+        existing_font = find_existing_font(name, size, styles)
+        if existing_font
+          existing_font
+        else
+          build_font(name, size, styles)
+        end
+      end
+
+      def dispose
+        @fonts.each { |font| font.dispose unless font.disposed? }
+        @fonts.clear
+      end
+
+      def find_existing_font(name, size, styles)
+        # Bit odd, but fonts on some OS's have multiple font_data elements,
+        # so check if any of them match.
+        @fonts.find do |font|
+          font.font_data.any? do |font_data|
+            font_data.name == name &&
+            # Windows seems to create fonts of height 15.75 when requesting 16
+            font_data.height.round == size.round &&
+            font_data.style == styles
+          end
+        end
+      end
+
+      def build_font(name, size, styles)
+        font = ::Swt::Graphics::Font.new @display, name, size, styles
+        @fonts << font
+        font
+      end
+
+      def styles_bitmask(styles)
+        styles.reduce { |result, s| result | s }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+class Shoes
+  module Swt
+    class TextBlock
+      # Resources created here need to be disposed (see #dispose). Note that
+      # this applies to ::Swt::Font and ::Swt::TextLayout. ::Swt::TextStyle
+      # does not need to be disposed, because it is not backed by system
+      # resources.
+      #
+      # The instance factories and our own instances will track these resources
+      # and ensure that they get properly disposed when TextBlock or Fitter
+      # tell us we're done.
+      #
+      # These are only expected to be called during contents_alignment
+      class TextSegment
+        DEFAULT_SPACING = 4
+
+        attr_reader :layout, :element_left, :element_top
+
+        extend Forwardable
+        def_delegators :@layout, :text, :text=, :bounds, :width, :spacing,
+                                 :line_bounds, :line_count, :line_offsets
+
+        def initialize(dsl, text, width)
+          @dsl = dsl
+          @layout = ::Swt::TextLayout.new Shoes.display
+          @font_factory = TextFontFactory.new
+          @style_factory = TextStyleFactory.new
+
+          layout.text = text
+          layout.width = width unless layout_fits_in?(width)
+          style_from(font_styling, @dsl.style)
+        end
+
+        def dispose
+          @layout.dispose unless @layout.disposed?
+          @font_factory.dispose
+          @style_factory.dispose
+        end
+
+        def position_at(element_left, element_top)
+          @element_left = element_left
+          @element_top = element_top
+          self
+        end
+
+        def get_location(cursor, trailing=false)
+          @layout.get_location(cursor, trailing)
+        end
+
+        def style_from(default_text_styles, style)
+          layout.justify = style[:justify]
+          layout.spacing = (style[:leading] || DEFAULT_SPACING)
+          layout.alignment = case style[:align]
+                             when 'center'; ::Swt::SWT::CENTER
+                             when 'right';  ::Swt::SWT::RIGHT
+                             else           ::Swt::SWT::LEFT
+                             end
+
+          set_style(TextStyleFactory.apply_styles(default_text_styles, style))
+        end
+
+        def set_style(styles, range=(0...text.length))
+          # If we've been given an empty/nonsense range, just ignore it
+          return unless range.count > 0
+
+          font = @font_factory.create_font(styles[:font_detail])
+          style = @style_factory.create_style(font, styles[:fg], styles[:bg], styles)
+          layout.set_style(style, range.min, range.max)
+        end
+
+        def font_styling
+          {
+            font_detail: {
+            name: @dsl.font,
+            size: @dsl.size,
+            styles:[::Swt::SWT::NORMAL]
+          }
+          }
+        end
+
+        def layout_fits_in?(width)
+          layout.bounds.width <= width
+        end
+
+        def height
+          layout.bounds.height - layout.spacing
+        end
+
+        def last_line_height
+          layout.line_bounds(layout.line_count - 1).height
+        end
+
+        def last_line_width
+          layout.line_bounds(layout.line_count - 1).width
+        end
+
+        def draw(graphics_context)
+          layout.draw(graphics_context, element_left, element_top)
+        end
+
+        # x,y in app coordinates, so translate for layout's element-local values
+        def in_bounds?(x, y)
+          layout.bounds.contains?(x - element_left, y - element_top)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+class Shoes
+  module Swt
+    class TextBlock
+      class TextSegmentCollection
+        extend Forwardable
+        def_delegators :@segments, :length
+
+        attr_reader :dsl, :default_text_styles
+
+        def initialize(dsl, segments, default_text_styles)
+          @dsl = dsl
+          @segments = segments
+          @default_text_styles = default_text_styles
+        end
+
+        def paint_control(graphic_context)
+          style_from(dsl.style)
+          style_segment_ranges(dsl.text_styles)
+          create_links(dsl.text_styles)
+          draw(graphic_context)
+          draw_cursor
+        end
+
+        def style_from(style)
+          @segments.each do |segment|
+            segment.style_from(default_text_styles, style)
+          end
+        end
+
+        def draw(graphic_context)
+          @segments.each do |segment|
+            segment.draw(graphic_context)
+          end
+        end
+
+        def draw_cursor
+          TextBlock::CursorPainter.new(dsl, self).draw
+        end
+
+        def style_segment_ranges(elements_by_range)
+          elements_by_range.each do |range, elements|
+            style = calculate_style(elements)
+            segment_ranges(range).each do |segment, inner_range|
+              segment.set_style(style, inner_range)
+            end
+          end
+        end
+
+        def calculate_style(elements)
+          elements.inject(default_text_styles) do |current_style, element|
+            if element.respond_to?(:style)
+              TextStyleFactory.apply_styles(current_style, element.style)
+            else
+              # Didn't know how to style from the element, so punt
+              current_style
+            end
+          end
+        end
+
+        def create_links(elements_by_range)
+          elements_by_range.each do |range, elements|
+            elements.each do |element|
+              if supports_links?(element)
+                element.gui.create_links_in(segment_ranges(range))
+              end
+            end
+          end
+        end
+
+        def supports_links?(element)
+          element.respond_to?(:gui) &&
+            element.gui &&
+            element.gui.respond_to?(:create_links_in)
+        end
+
+        def segment_at_text_position(index)
+          return @segments.last if index < 0
+          segment_ranges(index..index).first.first
+        end
+
+        # If we've got segments that style us across different ranges, it might
+        # be in either, or both, of the segments. This method figures out which
+        # segments apply, and what the relative ranges within each segment to use.
+        def segment_ranges(text_range)
+          return [] unless @segments.first # TODO WTF #636
+          first_text = @segments.first.text
+          slice = first_text[text_range]
+
+          if slice.nil? || slice.empty?
+            results_in_last_segment(text_range, first_text)
+          elsif slice.length < text_range.count
+            results_spanning_segments(text_range, first_text, slice)
+          else
+            results_in_first_segment(text_range)
+          end
+        end
+
+        def results_in_first_segment(text_range)
+          [[@segments.first, text_range]]
+        end
+
+        def results_spanning_segments(text_range, first_text, slice)
+          result = []
+          result << [@segments.first, (text_range.first..first_text.length)]
+          # If first == last, then requested range was longer than our one and
+          # only segment, so just stick with full range of the first segment.
+          if @segments.first != @segments.last
+            result << [@segments.last,  (0..text_range.count - slice.length - 1)]
+          end
+          result
+        end
+
+        def results_in_last_segment(text_range, first_text)
+          range_start = text_range.first - first_text.length
+          range_end   = text_range.last - first_text.length
+          [[@segments.last, (range_start..range_end)]]
+        end
+
+        # Returns the relative position within the appropriate segment for index
+        # in the overall DSL text
+        def relative_text_position(index)
+          if at_end?(index)
+            relative_end_position
+          elsif relative_in_first_segment?(index)
+            relative_in_first_segment(index)
+          else
+            relative_in_last_segment(index)
+          end
+        end
+
+        def relative_in_first_segment?(index)
+          index >= 0 &&
+            (@segments.one? || index < @segments.first.text.length)
+        end
+
+        def at_end?(index)
+          index < 0 || index > @dsl.text.length
+        end
+
+        def relative_end_position
+          @segments.last.text.length
+        end
+
+        def relative_in_first_segment(index)
+          index
+        end
+
+        def relative_in_last_segment(index)
+          index - @segments.first.text.length
+        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
+          @segments.first.line_bounds(0).height
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+class Shoes
+  module Swt
+    class TextStyleFactory
+      UNDERLINE_STYLES = {
+        "single" => 0,
+        "double" => 1,
+        "error" => 2,
+      }
+
+      def initialize
+        @colors = []
+      end
+
+      def dispose
+        @colors.each { |color| color.dispose unless color.disposed? }
+        @colors.clear
+      end
+
+      def create_style(font, foreground, background, style)
+        fg = swt_color(foreground, ::Shoes::COLORS[:black])
+        bg = swt_color(background)
+        @gui_style = ::Swt::TextStyle.new font, fg, bg
+        set_underline(style)
+        set_undercolor(style)
+        set_rise(style)
+        set_strikethrough(style)
+        set_strikecolor(style)
+        @gui_style
+      end
+
+      def self.apply_styles(gui_style, dsl_style)
+        gui_style[:font_detail][:styles] = parse_font_style(dsl_style)
+        gui_style[:font_detail][:name] = dsl_style[:font] if dsl_style[:font]
+        gui_style[:font_detail][:size] = dsl_style[:size] if dsl_style[:size]
+        gui_style[:fg] = dsl_style[:stroke]
+        gui_style[:bg] = dsl_style[:fill]
+        gui_style[:font_detail][:size] *= dsl_style[:size_modifier] if dsl_style[:size_modifier]
+        gui_style.merge(dsl_style)
+      end
+
+      def self.parse_font_style(style)
+        font_styles = []
+        font_styles << ::Swt::SWT::BOLD if style[:weight]
+        font_styles << ::Swt::SWT::ITALIC if style[:emphasis]
+        font_styles << ::Swt::SWT::NORMAL if !style[:weight] && !style[:emphasis]
+        font_styles
+      end
+
+      private
+      def set_rise(style)
+        @gui_style.rise = style[:rise]
+      end
+
+      def set_underline(style)
+        @gui_style.underline = style[:underline].nil? || style[:underline] == "none" ? false : true
+        @gui_style.underlineStyle = UNDERLINE_STYLES[style[:underline]]
+      end
+
+      def set_undercolor(style)
+        @gui_style.underlineColor = color_from_dsl style[:undercolor]
+      end
+
+      def set_strikethrough(style)
+        @gui_style.strikeout = style[:strikethrough].nil? || style[:strikethrough] == "none" ? false : true
+      end
+
+      def set_strikecolor(style)
+        @gui_style.strikeoutColor = color_from_dsl style[:strikecolor]
+      end
+
+      def swt_color(color, default = nil)
+        return color if color.is_a? ::Swt::Color
+        color_from_dsl color, default
+      end
+
+      def color_from_dsl(dsl_color, default = nil)
+        return nil if dsl_color.nil? and default.nil?
+        return color_from_dsl default if dsl_color.nil?
+        color = ::Swt::Color.new(Shoes.display, dsl_color.red, dsl_color.green, dsl_color.blue)
+
+        # Hold a reference to the color so we can dispose it when the time comes
+        @colors << color
+
+        color
+      end
+    end
+  end
+end

data/lib/shoes/swt/timer.rb

@@ -0,0 +1,19 @@
+class Shoes
+  module Swt
+    class Timer
+      def initialize(dsl, app, blk)
+        @blk = blk
+        task = Proc.new do
+          unless app.real.disposed?
+            eval_block
+          end
+        end
+        ::Swt.display.timer_exec(dsl.n, task)
+      end
+
+      def eval_block
+        @blk.call
+      end
+    end
+  end
+end

data/lib/shoes/swt/tooling/leak_hunter.rb

@@ -0,0 +1,35 @@
+require 'swt'
+require 'shoes/swt'
+# Interested what hometown is and what it does?
+# check here: https://github.com/jasonrclark/hometown
+require 'hometown'
+
+# All known subclasses of Swt::Graphics::Resource
+# see http://help.eclipse.org/helios/index.jsp?topic=%2Forg.eclipse.platform.doc.isv%2Freference%2Fapi%2Forg%2Feclipse%2Fswt%2Fpackage-summary.html
+[
+  ::Swt::Graphics::Color,
+  ::Swt::Graphics::Cursor,
+  ::Swt::Graphics::Font,
+  ::Swt::Graphics::Image,
+  ::Swt::Graphics::Path,
+  ::Swt::Graphics::Pattern,
+  ::Swt::Graphics::Region,
+  ::Swt::Graphics::TextLayout,
+  ::Swt::Graphics::Transform,
+
+  # Excluded GC as we don't create any directly and it's quite noisy
+  #::Swt::Graphics::GC,
+].each do |clazz|
+  Hometown.watch_for_disposal(clazz, :dispose)
+end
+
+Hometown.undisposed_report_at_exit
+
+# Register an internal keystroke for closing the app, making sure to clear
+# out the contents first (to avoid false positives for still-exiting elements.
+Shoes::InternalApp.add_global_keypress(:'control_alt_q') do
+  clear
+  quit
+end
+
+puts "Registered Ctrl+Alt+Q for leak hunting clean shutdown."