shoes-swt 4.0.0.pre2

data/lib/shoes/swt/image_pattern.rb

@@ -0,0 +1,31 @@
+class Shoes
+  module Swt
+    class ImagePattern
+      include Common::Remove
+
+      def initialize(dsl)
+        @dsl = dsl
+      end
+
+      def dispose
+        @image.dispose if @image
+        @pattern.dispose if @pattern
+      end
+
+      # Since colors are bound up (at least in specs) with image patterns,
+      # we can't safely touch images during initialize, so lazily load them.
+      def pattern
+        @image   ||= ::Swt::Image.new(Shoes.display, @dsl.path)
+        @pattern ||= ::Swt::Pattern.new(Shoes.display, @image)
+      end
+
+      def apply_as_fill(gc, left, top, width, height, angle = 0)
+        gc.set_background_pattern pattern
+      end
+
+      def apply_as_stroke(gc, left, top, width, height, angle = 0)
+        gc.set_foreground_pattern pattern
+      end
+    end
+  end
+end

data/lib/shoes/swt/input_box.rb

@@ -0,0 +1,73 @@
+class Shoes
+  module Swt
+    # Class is used by edit_box and edit_line
+    class InputBox
+      include Common::Child
+      include Common::Remove
+      include Common::PainterUpdatesPosition
+      include Common::Visibility
+      include Common::UpdatePosition
+      include ::Shoes::BackendDimensionsDelegations
+
+      attr_reader :real, :dsl, :parent
+
+      def initialize(dsl, parent, text_options)
+        @dsl          = dsl
+        @parent       = parent
+
+        @real = ::Swt::Widgets::Text.new(@parent.real, text_options)
+        @real.set_size dsl.element_width, dsl.element_height
+        @real.set_text dsl.style[:text]
+        @real.add_modify_listener do |event|
+          @dsl.call_change_listeners unless nothing_changed?(event)
+        end
+      end
+
+      def text
+        @real.text
+      end
+
+      def text=(value)
+        @last_text = @real.text
+        @real.text = value
+      end
+
+      def enabled(value)
+        @real.enable_widget value
+      end
+
+      def highlight_text(start_index, final_index)
+        @real.set_selection(start_index, final_index)
+      end
+
+      def caret_to(index)
+        @real.set_selection(index)
+      end
+
+      private
+      def nothing_changed?(event)
+        source = event.source
+        event.instance_of?(Java::OrgEclipseSwtEvents::ModifyEvent) &&
+        source.instance_of?(Java::OrgEclipseSwtWidgets::Text) &&
+        source.text == @last_text
+      end
+    end
+
+    class EditLine < InputBox
+      DEFAULT_STYLES = ::Swt::SWT::SINGLE | ::Swt::SWT::BORDER
+      def initialize(dsl, parent)
+        styles = DEFAULT_STYLES
+        styles |= ::Swt::SWT::PASSWORD if dsl.secret?
+        super(dsl, parent, styles)
+      end
+    end
+
+    class EditBox < InputBox
+      DEFAULT_STYLES = ::Swt::SWT::MULTI | ::Swt::SWT::BORDER | ::Swt::SWT::WRAP | ::Swt::SWT::V_SCROLL
+      def initialize(dsl, parent)
+        super(dsl, parent, DEFAULT_STYLES)
+      end
+    end
+
+  end
+end

data/lib/shoes/swt/key_listener.rb

@@ -0,0 +1,145 @@
+class Shoes
+  module Swt
+    class KeyListener
+      include ::Swt::KeyListener
+
+      def self.get_swt_constant(name)
+        ::Swt::SWT.const_get name
+      end
+
+      SPECIAL_KEY_NAMES = {}
+
+      %w[TAB PAGE_UP PAGE_DOWN HOME END F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12
+         F13 F14 F15].each do|key|
+        SPECIAL_KEY_NAMES[get_swt_constant key] = key.downcase
+      end
+      %w[UP DOWN LEFT RIGHT].each do |key|
+        SPECIAL_KEY_NAMES[get_swt_constant "ARROW_#{key}"] = key.downcase
+      end
+
+      SPECIAL_KEY_NAMES[::Swt::SWT::DEL] = "delete"
+      SPECIAL_KEY_NAMES[::Swt::SWT::BS]  = "backspace"
+      SPECIAL_KEY_NAMES[::Swt::SWT::ESC] = "escape"
+      SPECIAL_KEY_NAMES[::Swt::SWT::CR]  = "\n"
+
+      MODIFIER_KEYS = %w[CTRL SHIFT ALT CAPS_LOCK COMMAND].map do |key|
+        get_swt_constant key
+      end
+
+      def initialize(dsl, app, &blk)
+        @block = blk
+        @app = app
+        @app.add_key_listener(self)
+      end
+
+      def handle_key_event(event)
+        modifiers = modifier_keys(event)
+        character = character_key(event)
+        key_string = modifiers + character
+        key_string = key_string.to_sym if should_be_symbol?(event, modifiers)
+        eval_block key_string unless character.empty?
+      end
+
+      def remove
+        @app.remove_key_listener(self)
+      end
+
+      BUTTON_EXCLUDES = ["\n", " "]
+      COMBO_EXCLUDES  = %w[up down] + BUTTON_EXCLUDES
+
+      # For a variety of SWT controls, certain characters should not be passed
+      # to Shoes key listeners, since they're already handled by the controls.
+      #
+      #   * Buttons ignore activating key press (enter, space depending on OS)
+      #   * Text boxes ignore all key presses
+      #   * Combo boxes ignore up/down and activating key presses
+      def ignore_event?(event)
+        char = character_key(event)
+        case event.widget
+        when Java::OrgEclipseSwtWidgets::Button
+          BUTTON_EXCLUDES.include?(char)
+        when Java::OrgEclipseSwtWidgets::Text
+          true
+        when Java::OrgEclipseSwtWidgets::Combo
+          COMBO_EXCLUDES.include?(char)
+        else
+          # Default? Don't ignore it!
+          false
+        end
+      end
+
+      private
+
+      def eval_block(key_string)
+        @block.call key_string
+      end
+
+      def modifier_keys(event)
+        modifier_keys = ''
+        modifier_keys += 'control_' if control?(event)
+        modifier_keys += 'shift_' if shift?(event) && special_key?(event)
+        modifier_keys += 'alt_' if alt?(event)
+        modifier_keys
+      end
+
+      def alt?(event)
+        is_this_modifier_key?(event, ::Swt::SWT::ALT)
+      end
+
+      # NOTE: state_mask and key_code error for me so the java version is used
+      def is_this_modifier_key?(event, key)
+        (event.stateMask & key) == key
+      end
+
+      def shift?(event)
+        is_this_modifier_key?(event, ::Swt::SWT::SHIFT)
+      end
+
+      def control?(event)
+        is_this_modifier_key?(event, ::Swt::SWT::CTRL)
+      end
+
+      def character_key(event)
+        return '' if current_key_is_modifier?(event)
+        if special_key?(event)
+          SPECIAL_KEY_NAMES[event.keyCode]
+        elsif control?(event) || alt?(event)
+          character_for_modified_keypress(event)
+        else
+          event.character.chr('UTF-8')
+        end
+      end
+
+      def character_for_modified_keypress(event)
+        character = event.keyCode.chr('UTF-8')
+        if shift?(event)
+          character.upcase
+        else
+          character
+        end
+      end
+
+      def special_key?(event)
+        SPECIAL_KEY_NAMES[event.keyCode]
+      end
+
+      def current_key_is_modifier?(event)
+        MODIFIER_KEYS.include? event.keyCode
+      end
+
+      def should_be_symbol?(event, modifiers)
+        !modifiers.empty? || (special_key?(event) && !enter?(event))
+      end
+
+      def enter?(event)
+        event.keyCode == ::Swt::SWT::CR
+      end
+    end
+
+    class Keypress < KeyListener
+    end
+
+    class Keyrelease < KeyListener
+    end
+  end
+end

data/lib/shoes/swt/line.rb

@@ -0,0 +1,60 @@
+class Shoes
+  module Swt
+    class Line
+      include Common::Clickable
+      include Common::Stroke
+      include Common::Visibility
+      include Common::Remove
+      include Common::PainterUpdatesPosition
+      include ::Shoes::BackendDimensionsDelegations
+
+      attr_reader :dsl, :app
+      attr_reader :translated_point_a, :translated_point_b
+      attr_reader :transform
+
+      # @param [Shoes::Line] dsl The {Shoes::Line} implemented by this object
+      # @param [Shoes::Swt::App] app The {Swt::App} this object belongs to
+      # @param [Shoes::Point] point_a One endpoint of the line
+      # @param [Shoes::Point] point_b The other endpoint of the line
+      def initialize(dsl, app)
+        @dsl, @app = dsl, app
+        translate_according_to_enclosing_box
+        @painter = Painter.new(self)
+        @app.add_paint_listener(@painter)
+      end
+
+      def dispose
+        @transform.dispose unless @transform.disposed?
+      end
+
+      def angle
+        @dsl.angle
+      end
+
+      def update_position
+        translate_according_to_enclosing_box
+      end
+
+      private
+      def translate_according_to_enclosing_box
+        @translated_point_a = @dsl.point_a.to(-left, -top)
+        @translated_point_b = @dsl.point_b.to(-left, -top)
+        @transform          = ::Swt::Transform.new(::Swt.display)
+        @transform_elements = Java::float[6].new
+        @transform.get_elements @transform_elements
+        @transform.set_elements @transform_elements[0], @transform_elements[1], @transform_elements[2], @transform_elements[3], dsl.element_left, dsl.element_top
+      end
+
+      class Painter < Common::Painter
+        def draw(gc)
+          point_a, point_b = @obj.translated_point_a, @obj.translated_point_b
+          gc.draw_line(point_a.x, point_a.y, point_b.x, point_b.y)
+        end
+
+        # Don't do fill setup
+        def fill_setup(gc)
+        end
+      end
+    end
+  end
+end

data/lib/shoes/swt/link.rb

@@ -0,0 +1,31 @@
+class Shoes
+  module Swt
+    class Link
+      include Common::Clickable
+
+      attr_reader :app, :link_segments, :dsl
+
+      def initialize(dsl, app)
+        @app = app
+        @link_segments = []
+        @dsl = dsl
+      end
+
+      def remove
+        @link_segments.clear
+        remove_listener_for self, ::Swt::SWT::MouseDown
+      end
+
+      def create_links_in(text_segment_ranges)
+        @link_segments.clear
+        text_segment_ranges.each do |text_segment, range|
+          @link_segments << LinkSegment.new(text_segment, range)
+        end
+      end
+
+      def in_bounds?(x, y)
+        @link_segments.any? {|segment| segment.in_bounds?(x, y)}
+      end
+    end
+  end
+end

data/lib/shoes/swt/link_segment.rb

@@ -0,0 +1,111 @@
+class Shoes
+  module Swt
+    class LinkSegment
+      def initialize(text_segment, range)
+        @regions = []
+        @range = range
+        @text_segment = text_segment
+
+        # Don't create regions for empty links!
+        return unless @range.count > 0
+
+        add_regions_for_lines(lines_for_link)
+        offset_regions(text_segment.element_left, text_segment.element_top)
+      end
+
+      def add_regions_for_lines(lines)
+        first_line = lines.shift
+        last_line  = lines.pop
+
+        if last_line.nil?
+          add_region_for_single_line(first_line)
+        else
+          add_regions_for_first_and_last_lines(first_line, last_line)
+          add_regions_for_remaining_lines(lines)
+        end
+      end
+
+      def lines_for_link
+        line_bounds.select do |bound|
+          line_in_bounds?(bound)
+        end
+      end
+
+      def line_bounds
+        (0..layout.line_count-1).map do |index|
+          layout.line_bounds(index)
+        end
+      end
+
+      def line_in_bounds?(bound)
+        bound.y >= start_position.y && bound.y <= end_position.y
+      end
+
+      def add_region_for_single_line(first_line)
+        add_region(start_position.x, start_position.y,
+                   end_position.x,   end_position.y + first_line.height)
+      end
+
+      def add_regions_for_first_and_last_lines(first_line, last_line)
+        add_region(start_position.x, start_position.y,
+                   layout.width,     start_position.y + first_line.height)
+        add_region(0,              end_position.y,
+                   end_position.x, end_position.y + last_line.height)
+      end
+
+      def add_regions_for_remaining_lines(lines)
+        lines.each do |line|
+          add_region(line.x,              line.y,
+                     line.x + line.width, line.y + line.height)
+        end
+      end
+
+      def add_region(left, top, right, bottom)
+        @regions << Region.new(left, top, right, bottom)
+      end
+
+      def offset_regions(left, top)
+        @regions.each do |region|
+          region.offset_by!(left, top)
+        end
+      end
+
+      def in_bounds?(x, y)
+        @regions.any? {|region| region.in_bounds?(x, y)}
+      end
+
+      def start_position
+        @text_segment.get_location(@range.first, false)
+      end
+
+      def end_position
+        @text_segment.get_location(@range.last, true)
+      end
+
+      def layout
+        @text_segment.layout
+      end
+
+      class Region
+        def initialize(start_x, start_y, end_x, end_y)
+          @start_x = start_x
+          @start_y = start_y
+          @end_x = end_x
+          @end_y = end_y
+        end
+
+        def offset_by!(left, top)
+          @start_x += left
+          @end_x   += left
+
+          @start_y += top
+          @end_y   += top
+        end
+
+        def in_bounds?(x, y)
+          (@start_x..@end_x).include?(x) and (@start_y..@end_y).include?(y)
+        end
+      end
+    end
+  end
+end