shoes 4.0.0.pre1 → 4.0.0.pre2

data/lib/shoes/swt/rect.rb

@@ -1,31 +0,0 @@
-class Shoes
-  module Swt
-    class Rect
-      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, :corners
-
-
-      attr_reader :dsl, :app, :transform, :painter, :container
-
-      def initialize(dsl, app, opts ={}, &blk)
-        @dsl = dsl
-        @app = app
-        @opts = opts
-
-        @container = @app.real
-
-        @painter = RectPainter.new(self)
-        @app.add_paint_listener @painter
-        clickable blk if blk
-      end
-    end
-  end
-end

data/lib/shoes/swt/rect_painter.rb

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

@@ -1,122 +0,0 @@
-# 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],
-                        TextBlockCursorPainter           => [: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::Toggle         => [:toggle],
-                          ::Shoes::Common::Style => [:update_style],
-                          ::Shoes::TextBlock     => [:replace]}
-
-      CHANGED_POSITION = {::Shoes::CommonMethods => [:_position],
-                          ::Shoes::Dimensions    => [:left=, :top=, :width=,
-                                                     :height=,
-                                                     :displace_left=, :displace_top=],
-                          }
-
-      # 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

data/lib/shoes/swt/shape.rb

@@ -1,101 +0,0 @@
-class Shoes
-  module Swt
-    class Shape
-      include Common::Fill
-      include Common::Stroke
-      include Common::PainterUpdatesPosition
-
-
-      # Creates a new Shoes::Swt::Shape
-      #
-      # @param [Shoes::Shape] dsl The dsl object to provide gui for
-      # @param [Hash] opts Initialization options
-      #   If this shape is part of another shape (i.e. it is not responsible
-      #   for drawing itself), `opts` should be omitted
-      def initialize(dsl, app, opts = {})
-        @dsl = dsl
-        @app = app
-        @element = ::Swt::Path.new(::Swt.display)
-        @painter = Painter.new(self)
-        @app.add_paint_listener @painter
-      end
-
-      attr_reader :dsl, :app
-      attr_reader :element, :transform
-      attr_reader :painter
-
-      def line_to(x, y)
-        @element.line_to(x, y)
-      end
-
-      def move_to(x, y)
-        @element.move_to(x, y)
-      end
-
-      def quad_to *args
-        @element.quad_to *args
-      end
-
-      def curve_to(cx1, cy1, cx2, cy2, x, y)
-        @element.cubic_to(cx1, cy1, cx2, cy2, x, y)
-      end
-
-      def arc(x, y, width, height, start_angle, arc_angle)
-        @element.add_arc(x - (width / 2), y - (height / 2), width, height,
-                         -start_angle * 180 / ::Shoes::PI,
-                         (start_angle - arc_angle) * 180 / ::Shoes::PI)
-      end
-
-      def update_position
-        transform.translate(dsl.element_left, dsl.element_top)
-      end
-
-      def left
-        elements = Java::float[6].new
-        transform.get_elements(elements)
-        elements[4]
-      end
-
-      def top
-        elements = Java::float[6].new
-        transform.get_elements(elements)
-        elements[5]
-      end
-
-      alias_method :absolute_left, :left
-      alias_method :absolute_top, :top
-      alias_method :element_left, :left
-      alias_method :element_top, :top
-
-      def width
-        bounds = Java::float[4].new
-        @element.get_bounds(bounds)
-        bounds[2]
-      end
-
-      def height
-        bounds = Java::float[4].new
-        @element.get_bounds(bounds)
-        bounds[3]
-      end
-
-      alias_method :element_width, :width
-      alias_method :element_height, :height
-
-      def transform
-        @transform ||= ::Swt::Transform.new(::Swt.display)
-      end
-
-      class Painter < Common::Painter
-
-        def fill(gc)
-          gc.fill_path(@obj.element)
-        end
-
-        def draw(gc)
-          gc.draw_path(@obj.element)
-        end
-      end
-    end
-  end
-end

data/lib/shoes/swt/shoes_layout.rb

@@ -1,43 +0,0 @@
-class Shoes
-  module Swt
-    class ShoesLayout < ::Swt::Widgets::Layout
-
-      attr_accessor :gui_app
-
-      def layout(*dontcare)
-        dsl_app = @gui_app.dsl
-        height = dsl_app.height
-        scrollable_height = dsl_app.top_slot.contents_alignment
-        set_gui_size(height, scrollable_height)
-
-        vertical_bar = @gui_app.shell.getVerticalBar
-        vertical_bar.setVisible(scrollable_height > height)
-        if scrollable_height > height
-          handle_scroll_bar(vertical_bar, height, scrollable_height)
-        else
-          set_gui_location
-        end
-      end
-
-      private
-      def set_gui_size(height, scrollable_height)
-        width          = @gui_app.dsl.width
-        maximum_height = [scrollable_height, height].max
-        size           = @gui_app.real.compute_trim 0, 0, width, maximum_height
-        @gui_app.real.set_size(size.width, size.height)
-      end
-
-      def handle_scroll_bar(vertical_bar, height, scrollable_height)
-        vertical_bar.setThumb height * height / scrollable_height
-        vertical_bar.setMaximum scrollable_height - height + vertical_bar.getThumb
-        vertical_bar.increment = 10
-      end
-
-      def set_gui_location
-        location   = @gui_app.real.getLocation
-        location.y = 0
-        @gui_app.real.setLocation location
-      end
-    end
-  end
-end

data/lib/shoes/swt/slot.rb

@@ -1,25 +0,0 @@
-class Shoes
-  module Swt
-    class Slot
-      include Common::Container
-      include Common::Clickable
-      include Common::Toggle
-
-      def initialize(dsl, parent)
-        @dsl = dsl
-        @parent = parent
-        @real = parent.real
-
-        @app = @parent.app
-      end
-
-      # needed by Layouter code, but slots are no physical elements so they
-      def update_position
-      end
-
-      attr_reader :real, :dsl, :parent, :app
-    end
-    class Flow < Slot; end
-    class Stack < Slot; end
-  end
-end

data/lib/shoes/swt/sound.rb

@@ -1,119 +0,0 @@
-# JavaZOOM Sound-API Projects
-#  - Shared lib
-require 'support/tritonus_share.jar'
-#  - MP3 lib
-require 'support/mp3spi1.9.5.jar'
-require 'support/jl1.0.1.jar'
-#  - Ogg/Vorbis lib
-require 'support/jogg-0.0.7.jar'
-require 'support/jorbis-0.0.15.jar'
-require 'support/vorbisspi1.0.3.jar'
-
-class Shoes
-  module Swt
-    class Sound
-      JFile = java.io.File
-      import java.io.BufferedInputStream
-      import javax.sound.sampled
-      import java.io.IOException
-
-      BufferSize = 4096
-
-      def initialize(dsl)
-        @dsl = dsl
-      end
-
-      def filepath
-        @dsl.filepath
-      end
-
-      attr_accessor :mixer_channel, :audio_input_stream, :audio_format
-
-      def play
-        Thread.new do
-          begin
-            sound_file = JFile.new(self.filepath)
-
-            audio_input_stream = AudioSystem.getAudioInputStream(sound_file)
-            audio_format = audio_input_stream.getFormat
-
-            decoded_audio_format, decoded_audio_input_stream = decode_input_stream(audio_format, audio_input_stream)
-
-            # Play now.
-            rawplay(decoded_audio_format, decoded_audio_input_stream)
-            audio_input_stream.close
-
-          rescue UnsupportedAudioFileException => uafex
-            puts uafex.inspect, uafex.backtrace
-          rescue IOException => ioex
-            puts ioex.inspect, ioex.backtrace
-              #rescue JIOException => jioex
-              #  jioex.stacktrace
-          rescue LineUnavailableException => luex
-            puts luex.inspect, luex.backtrace
-          rescue Exception => e
-            puts e.inspect, e.backtrace
-          end
-        end
-      end
-
-      def decode_input_stream(audio_format, audio_input_stream)
-        case audio_format.encoding
-          when Java::JavazoomSpiVorbisSampledFile::VorbisEncoding, Java::JavazoomSpiMpegSampledFile::MpegEncoding
-            decoded_format = AudioFormat.new(AudioFormat::Encoding::PCM_SIGNED,
-                                             audio_format.getSampleRate(),
-                                             16,
-                                             audio_format.getChannels(),
-                                             audio_format.getChannels() * 2,
-                                             audio_format.getSampleRate(),
-                                             false)
-            decoded_audio_input_stream = AudioSystem.getAudioInputStream(decoded_format, audio_input_stream)
-
-            return decoded_format, decoded_audio_input_stream
-
-          else
-            return audio_format, audio_input_stream
-        end
-      end
-
-      def rawplay(decoded_audio_format, decoded_audio_input_stream)
-
-        #throws IOException, LineUnavailableException
-
-        sampled_data = Java::byte[BufferSize].new
-
-        line = getLine(decoded_audio_format)
-        if line != nil
-
-          # Start
-          line.start()
-          bytes_read = 0, bytes_written = 0
-          while bytes_read != -1
-
-            bytes_read = decoded_audio_input_stream.read(sampled_data, 0, sampled_data.length)
-            if bytes_read != -1
-
-              bytes_written = line.write(sampled_data, 0, bytes_read)
-            end
-          end
-          # Stop
-          line.drain()
-          line.stop()
-          line.close()
-          decoded_audio_input_stream.close()
-        end
-      end
-
-      def getLine(audioFormat)
-
-        #throws LineUnavailableException
-
-        res = nil
-        info = DataLine::Info.new(SourceDataLine.java_class, audioFormat)
-        res = AudioSystem.getLine(info)
-        res.open(audioFormat)
-        res
-      end
-    end
-  end
-end