rabbit 0.6.2

data/lib/rabbit/element/text-container-element.rb

@@ -0,0 +1,104 @@
+require 'rabbit/element/container-element'
+require 'rabbit/element/text-renderer'
+
+module Rabbit
+  module Element
+    module TextContainerElement
+      include ContainerElement
+      include TextRenderer
+
+      attr_reader :prop
+
+      alias prop_set __prop_set__
+      alias prop_get __prop_get__
+      alias prop_delete __prop_delete__
+
+      def draw_elements(canvas, x, y, w, h, simulation)
+        unless simulation
+          draw_layout(canvas, x, y)
+        end
+        [x, y + @height, w, h - @height]
+      end
+
+      def to_html(generator)
+        html = @elements.collect do |elem|
+          elem.to_html(generator)
+        end.join("")
+        markup_as_html(html)
+      end
+
+      def markuped_text
+        mt = @elements.collect do |elem|
+          elem.markuped_text
+        end.join("")
+        markup(mt)
+      end
+
+      def text
+        @elements.collect do |elem|
+          elem.text
+        end.join("")
+      end
+
+      def to_rd
+        text
+      end
+
+      def do_horizontal_centering?
+        super and not width.nil?
+      end
+
+      def compile(canvas, x, y, w, h)
+        super
+        text_compile(canvas, @x, @y, @w, @h)
+      end
+
+      def dirty?
+        super or text_dirty?
+      end
+
+      def empty?
+        /\A\s*\z/ =~ text
+      end
+
+      def clear_theme
+        container_clear_theme
+        super
+      end
+
+      def have_numerical_font_size?
+        super or @elements.any? {|elem| elem.have_numerical_font_size?}
+      end
+
+      protected
+      def initial_font_size_for_compute_font_size
+        [
+         super,
+         @elements.collect do |elem|
+           elem.initial_font_size_for_compute_font_size
+         end
+        ]
+      end
+
+      def compute_next_font_size(previous_size, scale)
+        i = -1
+        my_font_size, elements_font_size = previous_size
+        [
+         super(my_font_size, scale),
+         elements_font_size.collect do |size|
+           i += 1
+           @elements[i].compute_next_font_size(size, scale)
+         end
+        ]
+      end
+
+      def set_computed_font_size(new_size)
+        my_font_size, elements_font_size = new_size
+        elements_font_size.each_with_index do |size, i|
+          dirty! if @elements[i].set_computed_font_size(size)
+        end
+        super(my_font_size)
+      end
+    end
+  end
+end

data/lib/rabbit/element/text-element.rb

@@ -0,0 +1,59 @@
+require 'rabbit/element/text-renderer'
+
+module Rabbit
+  module Element
+    module TextElement
+      include TextRenderer
+
+      attr_reader :text
+
+      def initialize(text)
+        super()
+        @text = text
+      end
+
+      def text=(new_text)
+        old_text = @text
+        @text = new_text
+        dirty! if old_text != @text
+        @text
+      end
+
+      def substitute_text
+        result = yield(@text.dup)
+        return false if result == @text
+        case result
+        when Array
+          new_elements = result.collect do |element|
+            if element.is_a?(Base)
+              element
+            else
+              new_element = clone
+              new_element.text = element
+              new_element
+            end
+          end
+          parent.replace_element(self, *new_elements)
+        else
+          self.text = result
+        end
+        true
+      end
+
+      def draw_element(canvas, x, y, w, h, simulation)
+        unless simulation
+          draw_layout(canvas, x, y)
+        end
+        [x + width, y, w - width, h]
+      end
+
+      def to_html(generator)
+        text_to_html(generator)
+      end
+
+      def empty?
+        @text.nil? or /\A\s*\z/ =~ @text
+      end
+    end
+  end
+end

data/lib/rabbit/element/text-renderer.rb

@@ -0,0 +1,321 @@
+require 'rabbit/element/base'
+
+module Rabbit
+  module Element
+    module TextRenderer
+      include Base
+
+      attr_reader :layout
+      attr_reader :original_width, :original_height
+      attr_reader :first_line_width, :first_line_height
+
+      attr_writer :wrap_mode, :indent, :spacing
+
+      def initialize(*args, &block)
+        super
+        text_clear_theme
+      end
+
+      def text_renderer?
+        true
+      end
+
+      def align=(new_value)
+        if new_value.is_a?(String)
+          new_value = Pango::Layout.const_get("ALIGN_#{new_value.to_s.upcase}")
+        end
+        dirty! if @align != new_value
+        @align = new_value
+      end
+
+      def justify=(new_value)
+        new_value = true if new_value
+        dirty! if @justify != new_value
+        @justify = new_value
+      end
+
+      def width
+        if @width
+          @width + @padding_left + @padding_right
+        else
+          nil
+        end
+      end
+
+      def height
+        if @height
+          @height + @padding_top + @padding_bottom
+        else
+          nil
+        end
+      end
+      
+      def compile(canvas, x, y, w, h)
+        super
+        text_compile(canvas, x, y, w, h)
+      end
+
+      def text_compile(canvas, x, y, w, h)
+        if (@width and @width > @w) or (@height and @height > @h)
+          dirty!
+        end
+        if_dirty do
+          setup_draw_info(markuped_text, canvas, w)
+        end
+      end
+
+      def text_to_html(generator)
+        markup_as_html(text)
+      end
+
+      def do_horizontal_centering?
+        @horizontal_centering
+      end
+
+      def do_horizontal_centering(canvas, x, y, w, h)
+        self.align = Pango::Layout::ALIGN_CENTER
+      end
+     
+      def markuped_text
+        markup(text)
+      end
+
+      def clear_theme
+        super
+        text_clear_theme
+      end
+
+      def text_clear_theme
+        @layout = nil
+        @indent = 0
+        @spacing = 0
+        @wrap_mode = default_wrap_mode
+        @align = default_align
+        @justify = default_justify
+      end
+
+      def dirty!
+        super
+        @layout = nil
+      end
+      
+      def dirty?
+        super or text_dirty?
+      end
+
+      def text_dirty?
+        @layout.nil?
+      end
+
+      def text_props
+        props = {}
+        @prop.each do |name, formatter|
+          props[name] = formatter.value
+        end
+        props
+      end
+
+      def font_size
+        text_props["size"]
+      end
+
+      def pixel_font_size
+        _font_size = font_size
+        if _font_size
+          _font_size / Pango::SCALE
+        else
+          original_height
+        end
+      end
+
+      def have_numerical_font_size?
+        font_size.is_a?(Numeric)
+      end
+
+      def keep_in_size(proc_name=nil, &compute_max_size)
+        proc_name ||= "keep-in-size"
+        make_params = Proc.new do |canvas, x, y, w, h,
+                                   initial_width, initial_height,
+                                   max_width, max_height|
+          if (max_width and initial_width > max_width) or
+              (max_height and initial_height > max_height)
+            scale = 0.95
+            compare = Proc.new do |_width, _height|
+              (max_width.nil? or _width < max_width) and
+                (max_height.nil? or _height < max_height)
+            end
+            [scale, compare]
+          end
+        end
+        dynamic_font_size_computation(proc_name, compute_max_size, &make_params)
+      end
+
+      def as_large_as_possible(proc_name=nil, &compute_max_size)
+        proc_name ||= "as-large-as-possible"
+        make_params = Proc.new do |canvas, x, y, w, h,
+                                   initial_width, initial_height,
+                                   max_width, max_height|
+          if (max_width and initial_width > max_width) or
+              (max_height and initial_height > max_height)
+            scale = 0.95
+            compare = Proc.new do |_width, _height|
+              (max_width.nil? or _width < max_width) and
+                (max_height.nil? or _height < max_height)
+            end
+          else
+            scale = 1.05
+            compare = Proc.new do |_width, _height|
+              (max_width and _width > max_width) or
+                (max_height and _height > max_height)
+            end
+          end
+          [scale, compare]
+        end
+        dynamic_font_size_computation(proc_name, compute_max_size, &make_params)
+      end
+
+      private
+      def setup_draw_info(str, canvas, w)
+        layout = canvas.make_layout(str)
+        @original_width, @original_height = layout.pixel_size
+        @first_line_width = @original_width / layout.line_count
+        @first_line_height = @original_height / layout.line_count
+        if @wrap_mode
+          layout.set_width(w * Pango::SCALE)
+          layout.set_wrap(@wrap_mode)
+        else
+          layout.set_width(-1)
+        end
+        layout.set_alignment(@align)
+        layout.set_indent(@indent)
+        layout.set_spacing(@spacing)
+        layout.justify = @justify
+        layout.context_changed
+        width, height = layout.pixel_size
+        if layout.width != -1 and
+            (layout.alignment == Pango::Layout::ALIGN_CENTER or
+             layout.alignment == Pango::Layout::ALIGN_RIGHT)
+          width = layout.width / Pango::SCALE
+        end
+        @width, @height = width, height
+        @layout = layout
+      end
+      
+      def markup(str)
+        t = str
+        @prop.each do |name, formatter|
+          if formatter.text_formatter?
+            t = formatter.format(t)
+          end
+        end
+        t
+      end
+
+      def markup_as_html(str)
+        t = str
+        @prop.each do |name, formatter|
+          if formatter.html_formatter?
+            t = formatter.html_format(t)
+          end
+        end
+        t
+      end
+
+      def default_wrap_mode
+        Pango::Layout::WRAP_WORD_CHAR
+      end
+
+      def default_align
+        Pango::Layout::ALIGN_LEFT
+      end
+
+      def default_justify
+        false
+      end
+
+      def draw_layout(canvas, x, y)
+        color = prop_get("foreground")
+        color = color.value if color
+        canvas.draw_layout(@layout, x, y, color)
+      end
+
+      def dynamic_font_size_computation(proc_name, compute_max_size,
+                                        &make_params)
+        computed = false
+        min_width = nil
+        add_pre_draw_proc(proc_name) do |canvas, x, y, w, h, simulation|
+          if simulation and !computed and have_numerical_font_size?
+            max_width = max_height = nil
+            if compute_max_size
+              max_width, max_height = compute_max_size.call(self, canvas,
+                                                            x, y, w, h)
+            else
+              max_width = (pw || w) - padding_left - padding_right
+              max_height = (ph || h) - padding_top - padding_bottom
+              max_width = nil if max_width <= 0
+              max_height = nil if max_height <= 0
+            end
+
+            computed = true
+
+            if max_width and max_height
+              compute_font_size(canvas, x, y, w, h, max_width, max_height,
+                                make_params)
+            end
+          end
+          [x, y, w, h]
+        end
+      end
+
+      def compute_font_size(canvas, x, y, w, h, max_width, max_height,
+                            make_params)
+        compile(canvas, x, y, w, h) if dirty?
+        initial_width, initial_height = @layout.pixel_size
+        scale, compare = make_params.call(canvas, x, y, w, h,
+                                          initial_width, initial_height,
+                                          max_width, max_height)
+
+        return if scale.nil? or compare.nil?
+
+        size = new_size = initial_font_size_for_compute_font_size
+        current_layout_size = @layout.pixel_size
+        unless compare.call(*@layout.pixel_size)
+          loop do
+            new_size = compute_next_font_size(size, scale)
+            break if new_size == size
+            set_computed_font_size(new_size)
+            compile(canvas, x, y, w, h)
+            break if compare.call(*@layout.pixel_size)
+            size = new_size
+          end
+        end
+        if scale > 1
+          set_computed_font_size(size)
+        else
+          set_computed_font_size(new_size)
+        end
+      end
+
+      protected
+      def initial_font_size_for_compute_font_size
+        font_size
+      end
+
+      def compute_next_font_size(previous_size, scale)
+        if previous_size
+          (previous_size * scale).ceil
+        else
+          nil
+        end
+      end
+
+      def set_computed_font_size(new_size)
+        if new_size
+          font :size => new_size
+          dirty!
+        end
+        dirty?
+      end
+    end
+  end
+end