shoes 4.0.0.pre1 → 4.0.0.pre2

data/lib/shoes/swt/line.rb

@@ -1,57 +0,0 @@
-class Shoes
-  module Swt
-    class Line
-      include Common::Stroke
-      include Common::Toggle
-      include Common::Clear
-      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
-      # @param [Hash] opts Options
-      def initialize(dsl, app, opts = {})
-        @dsl, @app = dsl, app
-
-        translate_according_to_enclosing_box
-        @painter = Painter.new(self)
-        @app.add_paint_listener(@painter)
-      end
-
-      def angle
-        @dsl.angle
-      end
-
-      def update_position
-        @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
-
-      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
-        update_position
-      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

@@ -1,37 +0,0 @@
-class Shoes
-  module Swt
-    class Link
-      include Common::Clickable
-
-      attr_reader :app, :link_segments, :dsl
-
-      def initialize(dsl, app, opts={})
-        @app = app
-        @link_segments = []
-        @dsl = dsl
-
-        # Important to capture a block that executes the DSL's current block,
-        # not just the block the DSL had when initializing, since a `click`
-        # call can change the block but won't update the clickable listener.
-        # See issue #639 for how we'd like to fix this in clickable.
-        clickable self, Proc.new { dsl.execute_link }
-      end
-
-      def clear
-        @link_segments.clear
-        remove_listener_for(self)
-      end
-
-      def create_links_in(layout_ranges)
-        @link_segments.clear
-        layout_ranges.each do |layout, range|
-          @link_segments << LinkSegment.new(layout, 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

@@ -1,108 +0,0 @@
-class Shoes
-  module Swt
-    class LinkSegment
-      def initialize(fitted_layout, range)
-        @regions = []
-        @range = range
-        @fitted_layout = fitted_layout
-
-        add_regions_for_lines(lines_for_link)
-        offset_regions(fitted_layout.element_left, fitted_layout.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
-        @fitted_layout.get_location(@range.first, false)
-      end
-
-      def end_position
-        @fitted_layout.get_location(@range.last, true)
-      end
-
-      def layout
-        @fitted_layout.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

data/lib/shoes/swt/list_box.rb

@@ -1,49 +0,0 @@
-class Shoes
-  module Swt
-    class ListBox
-      include Common::Child
-      include Common::Clear
-      include Common::Toggle
-      include Common::UpdatePosition
-      include ::Shoes::BackendDimensionsDelegations
-
-      attr_reader :dsl, :parent
-
-      # Create a list box
-      #
-      # @param dsl    [Shoes::List_box] The Shoes DSL list box this represents
-      # @param parent [::Swt::Widgets::Composite] The parent element of this button
-      def initialize(dsl, parent)
-        @dsl = dsl
-        @parent = parent
-        @real = ::Swt::Widgets::Combo.new(
-          @parent.real,
-          ::Swt::SWT::DROP_DOWN | ::Swt::SWT::READ_ONLY
-        )
-        @real.set_size dsl.element_width, dsl.element_height
-        @real.add_selection_listener do |event|
-          @dsl.call_change_listeners
-        end
-      end
-
-      def update_items(values)
-        @real.items = values.map(&:to_s)
-      end
-
-      def text
-        text = @real.text
-        text == '' ? nil : text
-      end
-
-      def choose(item)
-        @real.text = item
-      end
-      
-      def enabled(value)
-        @real.enable_widget value
-      end
-    end
-  end
-end
-
-

data/lib/shoes/swt/mouse_move_listener.rb

@@ -1,61 +0,0 @@
-class Shoes
-  module Swt
-    class MouseMoveListener
-      include ::Swt::Events::MouseMoveListener
-
-      def initialize app
-        @app = app
-      end
-
-      def mouse_move(mouse_event)
-        @app.dsl.mouse_pos = [mouse_event.x, mouse_event.y]
-        @app.dsl.mouse_motion.each{|blk| eval_move_block blk, mouse_event}
-        mouse_shape_control mouse_event
-        mouse_leave_control mouse_event
-        mouse_hover_control mouse_event
-      end
-
-      private
-      def eval_move_block(blk, event)
-        blk.call event.x, event.y
-      end
-
-      def mouse_shape_control(mouse_event)
-        cursor = if cursor_over_clickable_element? mouse_event
-                   ::Swt::SWT::CURSOR_HAND
-                 else
-                   ::Swt::SWT::CURSOR_ARROW
-                 end
-        @app.shell.setCursor  Shoes.display.getSystemCursor(cursor)
-      end
-
-      def mouse_leave_control(mouse_event)
-        @app.dsl.mouse_hover_controls.each do |element|
-          if !mouse_on?(element, mouse_event) and element.hovered?
-            element.mouse_left
-            element.leave_proc.call element if element.leave_proc
-          end
-        end
-      end
-
-      def mouse_hover_control(mouse_event)
-        @app.dsl.mouse_hover_controls.each do |element|
-          if mouse_on?(element, mouse_event) and !element.hovered?
-            element.mouse_hovered
-            element.hover_proc.call element if element.hover_proc
-          end
-        end
-      end
-
-      def mouse_on?(element, mouse_event)
-        element.in_bounds? mouse_event.x, mouse_event.y
-      end
-
-      def cursor_over_clickable_element?(mouse_event)
-        @app.clickable_elements.any? do |element|
-          mouse_on? element, mouse_event
-        end
-      end
-    end
-  end
-end

data/lib/shoes/swt/oval.rb

@@ -1,53 +0,0 @@
-class Shoes
-  module Swt
-    class Oval
-      include Common::Fill
-      include Common::Stroke
-      include Common::Clickable
-      include Common::PainterUpdatesPosition
-      include Common::Toggle
-      include Common::Clear
-      include ::Shoes::BackendDimensionsDelegations
-
-      attr_reader :dsl, :app, :transform, :painter, :container
-
-
-      # @param [Shoes::Oval] dsl the dsl object to provide gui for
-      # @param [Shoes::Swt::App] app the app
-      # @param [Hash] opts options
-      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
-
-      def update_position
-        # No-op, since it has its own painter
-      end
-
-      class Painter < Common::Painter
-        def clipping
-          clipping = ::Swt::Path.new(Shoes.display)
-          clipping.add_arc(@obj.element_left, @obj.element_top,
-                           @obj.element_width, @obj.element_height, 0, 360)
-          clipping
-        end
-
-        def fill(graphics_context)
-          graphics_context.fill_oval(@obj.element_left, @obj.element_top,
-                                     @obj.element_width, @obj.element_height)
-        end
-
-        def draw(graphics_context)
-          sw = graphics_context.get_line_width
-          graphics_context.draw_oval(@obj.element_left+sw/2, @obj.element_top+sw/2,
-                                     @obj.element_width-sw, @obj.element_height-sw)
-        end
-      end
-    end
-  end
-end

data/lib/shoes/swt/progress.rb

@@ -1,35 +0,0 @@
-class Shoes
-  module Swt
-    class Progress
-      include Common::Child
-      include Common::Clear
-      include Common::Toggle
-      include Common::UpdatePosition
-      include ::Shoes::BackendDimensionsDelegations
-
-      attr_reader :parent, :real, :dsl
-
-      def initialize(dsl, parent)
-        @dsl = dsl
-        @parent = parent
-
-        @real = ::Swt::Widgets::ProgressBar.new(@parent.real,
-                                                ::Swt::SWT::SMOOTH)
-        @real.minimum = 0
-        @real.maximum = 100
-
-        if @dsl.element_width and @dsl.element_height
-          @real.setSize dsl.element_width, dsl.element_height
-        else
-          @real.pack
-          @dsl.element_width  = @real.size.x
-          @dsl.element_height = @real.size.y
-        end
-      end
-
-      def fraction=(value)
-        @real.selection = (value*100).to_i unless @real.disposed?
-      end
-    end
-  end
-end

data/lib/shoes/swt/radio.rb

@@ -1,29 +0,0 @@
-class Shoes
-  module Swt
-    # In Swt a radio button is actually just a
-    # button, so a lot of these methods are
-    # borrowed from button.rb
-    class Radio < CheckButton
-      attr_accessor :group
-
-      # Create a radio button
-      #
-      # @param [Shoes::Radio] dsl The Shoes DSL radio this represents
-      # @param [::Swt::Widgets::Composite] parent The parent element of this button
-      # @param [Proc] blk The block of code to call when this button is activated
-      def initialize(dsl, parent)
-        super(dsl, parent, ::Swt::SWT::RADIO)
-        self.group = dsl.group
-      end
-
-      def group=(value)
-        group_lookup = RadioGroup.group_lookup
-        group_lookup[@group].remove(self) unless @group.nil?
-        @group = value || RadioGroup::DEFAULT_RADIO_GROUP
-        group_lookup[@group].add self
-      end
-    end
-  end
-end
-
-

data/lib/shoes/swt/radio_group.rb

@@ -1,54 +0,0 @@
-class Shoes
-  module Swt
-    # In Swt radio groups are managed by composites which occupy space 
-    # and can interfere with users interacting with other controls. Here
-    # we simulate radio groups so that they can all be in one composite.
-    class RadioGroup
-      extend Forwardable
-      include Enumerable
-
-      DEFAULT_RADIO_GROUP = "Default Radio Group"
-
-      @group_lookup = Hash.new { |h, k| h[k] = RadioGroup.new(k) }
-
-      attr_reader :name
-      def_delegators :@radio_buttons, :each, :length, :empty?
-
-      def initialize(name = DEFAULT_RADIO_GROUP)
-        @name = name
-        @radio_buttons = []
-        @selection_listeners = []
-      end
-
-      def add(radio_button)
-        return if @radio_buttons.include?(radio_button) 
-        @radio_buttons << radio_button
-
-        selection_listener = SelectionListener.new radio_button do |selected_radio, event|
-          select_only_one_radio_in_group(selected_radio)
-        end
-        @selection_listeners << selection_listener
-        radio_button.real.add_selection_listener selection_listener
-      end
-
-      def remove(radio_button)
-        index = @radio_buttons.index(radio_button)
-        return if index.nil?
-        @radio_buttons.delete_at(index)
-
-        radio_button.real.remove_selection_listener @selection_listeners[index]
-        @selection_listeners.delete_at(index)
-      end
-
-      def self.group_lookup
-        @group_lookup
-      end
-
-      def select_only_one_radio_in_group(selected_radio)
-        @radio_buttons.each do |radio| 
-          radio.real.set_selection(radio == selected_radio) 
-        end
-      end
-    end
-  end
-end