shoes 4.0.0.pre1 → 4.0.0.pre2

data/lib/shoes/swt/text_block_painter.rb

@@ -1,49 +0,0 @@
-class Shoes
-  module Swt
-    class TextBlockPainter
-      include ::Swt::Events::PaintListener
-      include Common::Resource
-
-      attr_reader :app
-      def initialize(dsl)
-        @dsl = dsl
-        @opts = @dsl.opts
-        @app = @dsl.app.gui
-      end
-
-      def paintControl(paint_event)
-        gcs_reset(paint_event.gc)
-        return if @dsl.hidden?
-
-        draw_layouts(paint_event.gc)
-        draw_text_cursor
-      end
-
-      def draw_layouts(graphic_context)
-        layouts = FittedTextLayoutCollection.new(@dsl.gui.fitted_layouts,
-                                                 default_text_styles)
-        layouts.paint_control(@dsl, graphic_context)
-      end
-
-      def draw_text_cursor
-        TextBlockCursorPainter.new(@dsl, @dsl.gui.fitted_layouts).draw
-      end
-
-      private
-
-      def default_text_styles
-        {
-          :fg          => @opts[:fg],
-          :bg          => @opts[:bg],
-          :strikecolor => @opts[:strikecolor],
-          :undercolor  => @opts[:undercolor],
-          :font_detail => {
-            :name   => @dsl.font,
-            :size   => @dsl.font_size,
-            :styles => [::Swt::SWT::NORMAL]
-          }
-        }
-      end
-    end
-  end
-end

data/lib/shoes/swt/text_font_factory.rb

@@ -1,27 +0,0 @@
-class Shoes
-  module Swt
-    class TextFontFactory
-      def initialize
-        @fonts = []
-      end
-
-      def create_font(font_style)
-        name = font_style[:name]
-        size = font_style[:size]
-        styles = font_style[:styles].reduce { |result, s| result | s }
-
-        font = ::Swt::Graphics::Font.new Shoes.display, name, size, styles
-
-        # Hold a reference to the font so we can dispose it when the time comes
-        @fonts << font
-
-        font
-      end
-
-      def dispose
-        @fonts.each { |font| font.dispose unless font.disposed? }
-        @fonts.clear
-      end
-    end
-  end
-end

data/lib/shoes/swt/text_style_factory.rb

@@ -1,88 +0,0 @@
-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, opts)
-        fg = swt_color(foreground, ::Shoes::COLORS[:black])
-        bg = swt_color(background)
-        @style = ::Swt::TextStyle.new font, fg, bg
-        set_underline(opts)
-        set_undercolor(opts)
-        set_rise(opts)
-        set_strikethrough(opts)
-        set_strikecolor(opts)
-        @style
-      end
-
-      def self.apply_styles(styles, opts)
-        styles[:font_detail][:styles] = parse_font_style(opts)
-        styles[:font_detail][:name] = opts[:font] if opts[:font]
-        styles[:font_detail][:size] = opts[:size] if opts[:size]
-        styles[:fg] = opts[:stroke]
-        styles[:bg] = opts[:fill]
-        styles[:font_detail][:size] *= opts[:size_modifier] if opts[:size_modifier]
-        styles.merge(opts)
-      end
-
-      def self.parse_font_style(opts)
-        font_styles = []
-        font_styles << ::Swt::SWT::BOLD if opts[:weight]
-        font_styles << ::Swt::SWT::ITALIC if opts[:emphasis]
-        font_styles << ::Swt::SWT::NORMAL if !opts[:weight] && !opts[:emphasis]
-        font_styles
-      end
-
-      private
-      def set_rise(opts)
-        @style.rise = opts[:rise]
-      end
-
-      def set_underline(opts)
-        @style.underline = opts[:underline].nil? || opts[:underline] == "none" ? false : true
-        @style.underlineStyle = UNDERLINE_STYLES[opts[:underline]]
-      end
-
-      def set_undercolor(opts)
-        @style.underlineColor = color_from_dsl opts[:undercolor]
-      end
-
-      def set_strikethrough(opts)
-        @style.strikeout = opts[:strikethrough].nil? || opts[:strikethrough] == "none" ? false : true
-      end
-
-      def set_strikecolor(opts)
-        @style.strikeoutColor = color_from_dsl opts[: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

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

@@ -1,84 +0,0 @@
-require 'swt'
-require 'shoes/swt'
-
-$callers = {}
-$untracked_disposals = {}
-
--> do
-  # 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
-  classes = [
-    ::Swt::Graphics::Color,
-    ::Swt::Graphics::Cursor,
-    ::Swt::Graphics::Font,
-    ::Swt::Graphics::GC,
-    ::Swt::Graphics::Image,
-    ::Swt::Graphics::Path,
-    ::Swt::Graphics::Pattern,
-    ::Swt::Graphics::Region,
-    ::Swt::Graphics::TextLayout,
-    ::Swt::Graphics::Transform,
-  ]
-
-  create_key = ->(klass, backtrace) do
-    "[#{klass}]\n" + backtrace.join("\n\t")
-  end
-
-  classes.each do |klass|
-    klass.class_eval do
-      define_singleton_method(:new) do |*args|
-        key = create_key.call(self.name, caller)
-        $callers[key] ||= 0
-        $callers[key] += 1
-
-        result = super(*args)
-        result.instance_variable_set(:@__shoes_creation_backtrace, key)
-        result
-      end
-
-      define_method(:dispose) do |*args|
-        if $callers[@__shoes_creation_backtrace]
-          $callers[@__shoes_creation_backtrace] -= 1
-        else
-          key = create_key.call(self.class.name, caller)
-          $untracked_disposals[key] ||= 0
-          $untracked_disposals[key] += 1
-        end
-        super(*args)
-      end
-    end
-  end
-end.call
-
-at_exit do
-  count_for_class_and_backtrace = ->(hash) do
-    hash.map do |k, v|
-      if v > 0
-        "#{v} => #{k}"
-      end
-    end.compact.join("\n\n")
-  end
-
-  totals = ->(hash) do
-    hash.inject({}) do |memo, (k, v)|
-      klass = k.split("\n").first
-      memo[klass] ||= 0
-      memo[klass] += v
-      memo
-    end.map do |k, v|
-      v == 0 ? nil : " %-42s %5d" % [k, v]
-    end.compact.join("\n")
-  end
-
-  puts "Undisposed resources:"
-  puts count_for_class_and_backtrace.call($callers)
-  puts
-  puts "Resources disposed without being tracked:"
-  puts count_for_class_and_backtrace.call($untracked_disposals)
-  puts
-  puts "Undisposed resource totals:"
-  puts totals.call($callers)
-  puts
-  puts "Untracked disposal totals:"
-  puts totals.call($untracked_disposals)
-end

data/lib/shoes/text.rb

@@ -1,14 +0,0 @@
-class Shoes
-  class Text
-    def initialize texts, color=nil
-      @texts = texts
-      @color = color
-      @to_s = @texts.map(&:to_s).join
-    end
-    attr_reader :to_s, :texts, :color
-    attr_accessor :parent
-    def app
-      @parent.app
-    end
-  end
-end

data/lib/shoes/text_block.rb

@@ -1,162 +0,0 @@
-class Shoes
-  DEFAULT_TEXTBLOCK_FONT = "Arial"
-
-  class TextBlock
-    include CommonMethods
-    include Common::Clickable
-    include DimensionsDelegations
-
-    attr_reader   :gui, :parent, :text, :contents, :app, :text_styles, :dimensions, :opts
-    attr_accessor :calculated_width, :font, :font_size, :cursor, :textcursor
-
-    def initialize(app, parent, text, font_size, opts = {})
-      texts = Array(text)
-      @parent             = parent
-      @app                = app
-      @opts               = opts
-      @font               = @app.font || DEFAULT_TEXTBLOCK_FONT
-      @font_size          = @opts[:size] || font_size
-      @contents           = texts
-      @text               = texts.map(&:to_s).join
-      @text_styles        = gather_text_styles(self, texts)
-
-      @opts[:stroke] = Shoes::Color.new(@opts[:stroke]) if @opts[:stroke].is_a?(String)
-      @opts[:fill] = Shoes::Color.new(@opts[:fill]) if @opts[:fill].is_a?(String)
-
-      @dimensions   = Dimensions.new parent, opts
-
-      handle_opts @opts
-
-      @opts = @app.style.merge(@opts)
-
-      @gui = Shoes.configuration.backend_for(self)
-      @parent.add_child(self)
-
-      clickable_options(@opts)
-    end
-
-    def in_bounds?(*args)
-      @gui.in_bounds?(*args)
-    end
-
-    def update_text_styles(texts)
-      @text_styles = gather_text_styles(self, texts)
-    end
-
-    def text=(*values)
-      replace *values[0]
-    end
-
-    def replace(*values)
-      @text = values.map(&:to_s).join
-      @gui.replace *values
-    end
-
-    def to_s
-      self.text
-    end
-
-    # Since we flow, try to fit in almost any space
-    def fitting_width
-      10
-    end
-
-    # We take over a bunch of the absolute_* measurements since the jagged
-    # shape of a flowed TextBlock doesn't follow the usual rules for dimensions
-    # when we get to positioning (which is the main use of these values).
-    def absolute_right=(value)
-      @absolute_right = value
-    end
-
-    def absolute_right
-      return @dimensions.absolute_right if @absolute_right.nil?
-      @absolute_right
-    end
-
-    def absolute_bottom=(value)
-      @absolute_bottom = value
-    end
-
-    def absolute_bottom
-      return absolute_top + height if @absolute_bottom.nil?
-      @absolute_bottom
-    end
-
-    def width
-      @dimensions.width || self.calculated_width
-    end
-
-    # If an explicit width's set, it's used. If not, we look to the parent.
-    def containing_width
-      (@dimensions.width || parent.width) - (margin_left + margin_right)
-    end
-
-    # This is the width the text block initially wants to try and fit into.
-    def desired_width(containing=containing_width)
-      parent.absolute_left + containing - self.absolute_left
-    end
-
-    def contents_alignment(current_position=nil)
-      @gui.contents_alignment(current_position)
-    end
-
-    def textcursor(line_height = 0)
-      @textcursor ||= app.textcursor(line_height)
-    end
-
-    def has_textcursor?
-      @textcursor
-    end
-
-    def links
-      @contents.select do |element|
-        element.is_a?(Shoes::Link)
-      end
-    end
-
-    private
-
-    def gather_text_styles(parent, texts, styles={}, start_point=0)
-      texts.each do |text|
-        if text.is_a? Shoes::Text
-          text.parent = parent
-          end_point = start_point + text.to_s.length - 1
-          range = start_point..end_point
-          styles[range] ||= []
-          styles[range] << text
-          gather_text_styles(text, text.texts, styles, start_point)
-        end
-        start_point += text.to_s.length
-      end
-      styles
-    end
-
-    def handle_opts(opts)
-      parse_font_opt opts[:font] if opts.has_key? :font
-    end
-
-    def parse_font_opt(type)
-      size_regex = /(\d+)(\s*px)?/
-      style_regex = /none|bold|normal|oblique|italic/i # TODO: add more
-
-      font_family = type.gsub(style_regex,'').gsub(size_regex,'').
-                  split(',').map { |x| x.strip.gsub(/["]/,'') }
-
-      @font = font_family.first unless (font_family.size == 1 and
-        font_family[0] == "") or font_family.size == 0
-
-      fsize = size_regex.match(type)
-      @font_size = fsize[1].to_i unless fsize.nil?
-
-      # TODO: Style options
-    end
-  end
-
-  class Banner < TextBlock; end
-  class Title < TextBlock; end
-  class Subtitle < TextBlock; end
-  class Tagline < TextBlock; end
-  class Caption < TextBlock; end
-  class Para < TextBlock; end
-  class Inscription < TextBlock; end
-end