shoes-swt 4.0.0.pre2

data/lib/shoes/swt/list_box.rb

@@ -0,0 +1,48 @@
+class Shoes
+  module Swt
+    class ListBox
+      include Common::Child
+      include Common::Remove
+      include Common::Visibility
+      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
+        update_items @dsl.items
+      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

@@ -0,0 +1,67 @@
+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
+          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
+          end
+        end
+      end
+
+      def mouse_on?(element, mouse_event)
+        element_visible?(element) && element.in_bounds?(mouse_event.x, mouse_event.y)
+      end
+
+      def element_visible?(element)
+        if element.respond_to?(:visible?)
+          element.visible?
+        else
+          false
+        end
+      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

@@ -0,0 +1,52 @@
+class Shoes
+  module Swt
+    class Oval
+      include Common::Fill
+      include Common::Stroke
+      include Common::Clickable
+      include Common::PainterUpdatesPosition
+      include Common::Visibility
+      include Common::Remove
+      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)
+        @dsl = dsl
+        @app = app
+        @container = @app.real
+
+        @painter = Painter.new(self)
+        @app.add_paint_listener @painter
+      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

@@ -0,0 +1,35 @@
+class Shoes
+  module Swt
+    class Progress
+      include Common::Child
+      include Common::Remove
+      include Common::Visibility
+      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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,54 @@
+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

data/lib/shoes/swt/rect.rb

@@ -0,0 +1,30 @@
+class Shoes
+  module Swt
+    class Rect
+      extend Forwardable
+      include Common::Fill
+      include Common::Stroke
+      include Common::Clickable
+      include Common::PainterUpdatesPosition
+      include Common::Visibility
+      include Common::Remove
+      include ::Shoes::BackendDimensionsDelegations
+
+      def_delegators :dsl, :angle
+
+      attr_reader :dsl, :app, :transform, :painter
+
+      def initialize(dsl, app)
+        @dsl = dsl
+        @app = app
+
+        @painter = RectPainter.new(self)
+        @app.add_paint_listener @painter
+      end
+
+      def corners
+        dsl.curve
+      end
+    end
+  end
+end

data/lib/shoes/swt/rect_painter.rb

@@ -0,0 +1,23 @@
+class Shoes
+  module Swt
+    class RectPainter < Common::Painter
+      def fill(graphics_context)
+        graphics_context.fill_round_rectangle(@obj.element_left,
+                                              @obj.element_top,
+                                              @obj.element_width,
+                                              @obj.element_height,
+                                              @obj.corners*2,
+                                              @obj.corners*2)
+      end
+
+      def draw(gc)
+        stroke_width = gc.get_line_width
+        gc.draw_round_rectangle(@obj.element_left+stroke_width/2,
+                                @obj.element_top+stroke_width/2,
+                                @obj.element_width-stroke_width,
+                                @obj.element_height-stroke_width,
+                                @obj.corners*2, @obj.corners*2)
+      end
+    end
+  end
+end

data/lib/shoes/swt/redrawing_aspect.rb

@@ -0,0 +1,123 @@
+# This file uses the after_do gem, which you probably haven't heard of (yet)
+# It basically works like Class.after :method do ... end
+# So for every instance of Class, after method is executed the block you
+# gave it is executed.
+# Here it is used to redraw the application, after specific methods are called.
+# So that everything belonging to the aspect of redrawing is in one file.
+# There is more documentation up here: https://github.com/PragTob/after_do
+
+class Shoes
+  module Swt
+    class RedrawingAspect
+
+      NEED_TO_UPDATE =
+          {Animation                        => [:eval_block],
+           Button                           => [:eval_block],
+           Common::Clickable::ClickListener => [:eval_block],
+           ::Shoes::InternalApp             => [:execute_block],
+           Keypress                         => [:eval_block],
+           Keyrelease                       => [:eval_block],
+           MouseMoveListener                => [:eval_move_block],
+           TextBlock::CursorPainter         => [:move_textcursor],
+           Timer                            => [:eval_block],
+           ::Shoes::Common::Changeable      => [:call_change_listeners]}
+      # only the main thread may draw
+      NEED_TO_ASYNC_UPDATE_GUI = {::Shoes::Download => [:eval_block]}
+
+      # These need to trigger a redraw
+      SAME_POSITION    = {Common::Visibility      => [:update_visibility],
+                          Image                   => [:update_image],
+                          ::Shoes::Common::Style  => [:update_style],
+                          ::Shoes::Common::Remove => [:remove],
+                          ::Shoes::Slot           => [:mouse_hovered,
+                                                      :mouse_left],
+                          ::Shoes::TextBlock      => [:replace]}
+
+      CHANGED_POSITION = {::Shoes::Common::Positioning => [:_position]}
+
+      # These methods trigger SWT painting listeners, so we need to be sure
+      # that positioning has run properly before allowing them to continue.
+      NEED_CONTENTS_ALIGNMENT = {
+                          ::Shoes::Swt::Dialog    => [:ask_color,
+                                                      :dialog_chooser,
+                                                      :open_message_box],
+                          ::Shoes::Swt::AskDialog => [:open]
+                          }
+
+
+      attr_reader :app
+
+      def initialize(swt_app, display)
+        @app = swt_app
+        @display = display
+        extend_needed_classes
+        add_redraws
+      end
+
+      def remove_redraws
+        affected_classes.each {|klass| klass.remove_all_callbacks}
+      end
+
+      private
+      def extend_needed_classes
+        affected_classes.each {|klass| klass.extend AfterDo}
+      end
+
+      def affected_classes
+        classes = NEED_TO_UPDATE.keys +
+                  NEED_TO_ASYNC_UPDATE_GUI.keys +
+                  NEED_CONTENTS_ALIGNMENT.keys +
+                  SAME_POSITION.keys +
+                  CHANGED_POSITION.keys
+        classes.uniq
+      end
+
+      def add_redraws
+        after_every NEED_TO_UPDATE do update_gui end
+        after_every NEED_TO_ASYNC_UPDATE_GUI do
+          @display.asyncExec do update_gui end
+        end
+        after_every SAME_POSITION do |*args, element|
+          element = element.dsl if element.respond_to? :dsl
+          redraw_element element, false
+        end
+        # need to redraw old occupied area and newly occupied area
+        before_and_after_every CHANGED_POSITION do |*args, element|
+          redraw_element element
+        end
+        before_every NEED_CONTENTS_ALIGNMENT do |*args|
+          app.dsl.top_slot.contents_alignment
+        end
+      end
+
+      def update_gui
+        app.flush unless app.disposed?
+      end
+
+      def redraw_element(element, include_children = true)
+        redraw_area element.element_left, element.element_top,
+                    element.element_width, element.element_height,
+                    include_children
+      end
+
+      def redraw_area(left, top, width, height, include_children = true)
+        unless app.disposed?
+          app.redraw left, top, width, height, include_children
+        end
+      end
+
+      def after_every(hash, &blk)
+        hash.each {|klass, methods| klass.after methods, &blk }
+      end
+
+      def before_and_after_every(hash, &blk)
+        before_every hash, &blk
+        after_every hash, &blk
+      end
+
+      def before_every(hash, &blk)
+        hash.each {|klass, methods| klass.before methods, &blk }
+      end
+    end
+  end
+end