dynamic_images 1.0.0

data/lib/elements/image_element.rb

@@ -0,0 +1,82 @@
+require File.dirname(__FILE__) + '/element_interface.rb'
+
+module DynamicImageElements
+  # Element providing rendering of image.
+  class ImageElement
+    include ElementInterface
+
+    # Image element accepts source as path to image file and options +Hash+.
+    #
+    # === Options
+    # Options can contain general attributes specified by BlockElement if it's created by it.
+    #
+    # [:alpha]
+    #   Makes image semi-transparent. Valid values are 0.0 - 1.0 or "0%" - "100%". Default is 1.0.
+    # [:crop]
+    #   Sets cropping rectangle by values in this order: [x, y, width, height]. Use +Array+ or +String+ to describe it, values in +String+ must be separated by space char.
+    # [:height]
+    #   Sets height of image.
+    # [:width]
+    #   Sets width of image.
+    #
+    def initialize(source, options, parent)
+      @source = source
+      @options = options
+      @parent = parent
+      use_options :margin
+      if @options[:crop].is_a? Array
+        @crop = (@options[:crop].flatten.map{|v| v.class == Fixnum || v.class == Float || v.class == String ? v.to_i : 0} + [0, 0, 0, 0])[0..3]
+      else
+        @crop = (@options[:crop].to_s.scan(/\-?\d+/).flatten.map(&:to_i) + [0, 0, 0, 0])[0..3]
+      end
+    end
+
+    private
+    def image
+      unless @image
+        if @source.to_s =~ /\.png$/i
+          @image = Cairo::ImageSurface.from_png @source
+        else
+          if defined? Gdk
+            @image = Gdk::Pixbuf.new @source
+          else
+            raise "Unsupported source format of: #{@source}"
+          end
+        end
+      end
+      @image
+    end
+
+    def inner_size
+      size = [0, 0]
+      unless @options[:width] && @options[:height]
+        size = [image.width, image.height]
+      end
+      size[0] = @crop[2] if @crop[2] > 0
+      size[1] = @crop[3] if @crop[3] > 0
+      size[0] = @options[:width] if @options[:width]
+      size[1] = @options[:height] if @options[:height]
+      size
+    end
+
+    def draw(x, y, endless)
+      w, h = element_size
+      imgsize = [image.width, image.height]
+      imgsize[0] = @crop[2] if @crop[2] > 0
+      imgsize[1] = @crop[3] if @crop[3] > 0
+      scale = [w.to_f/imgsize[0].to_f, h.to_f/imgsize[1].to_f]
+      context.scale *scale
+      context.save
+      if image.is_a? Cairo::Surface
+        context.set_source image, x/scale[0]-@crop[0], y/scale[1]-@crop[1]
+      else
+        context.set_source_pixbuf image, x/scale[0]-@crop[0], y/scale[1]-@crop[1]
+      end
+      context.rectangle x/scale[0], y/scale[1], w/scale[0], h/scale[1]
+      context.clip
+      context.paint @options[:alpha]
+      context.restore
+      context.scale 1.0/scale[0], 1.0/scale[1]
+    end
+  end
+end

data/lib/elements/table_cell_element.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/block_element.rb'
+
+module DynamicImageElements
+  # Element is used for compositing another elements in it. It's inherited from BlockElement and can be used in same way.
+  class TableCellElement < BlockElement
+
+    # Table cell element accepts options +Hash+. Block can be given and class provides element self to composite elements in it.
+    #
+    # See BlockElement.new for more information
+    #
+    # === Options
+    # Options are same as for BlockElement. You can also use further options to set cell behavior.
+    #
+    # [:colspan]
+    #   Sets number of columns which this cells takes. Don't create next cells for already taken space.
+    # [:rowspan]
+    #   Sets number of rows which this cells takes. Don't create next cells for already taken space.
+    # [:width]
+    #   Same as described in BlockElement. You can also set <tt>"0%"</tt> to fit all remaining space and ather elements will fit to its minimum size.
+    #
+    def initialize(options, parent = nil, &block) # :yields: block_element
+      super options, parent, &block
+    end
+
+    # Gets width for inner elements
+    def width #:nodoc:
+      @options[:width]
+    end
+    # Gets height for inner elements
+    def height #:nodoc:
+      @options[:height]
+    end
+  end
+end

data/lib/elements/table_element.rb

@@ -0,0 +1,220 @@
+require File.dirname(__FILE__) + '/element_interface.rb'
+require File.dirname(__FILE__) + '/table_cell_element.rb'
+
+module DynamicImageElements
+  # Element is used for creating a table structure. It is composition of cells and rows of table.
+  class TableElement
+    include ElementInterface
+
+    # Table element accepts options +Hash+. Block can be given and class provides element self to composite cells in it.
+    #
+    # You can create table structure by two ways. By basic hierarchy where cells are nested in row block or set columns number by :cols option and use cells only. You can also combine these two ways by using row method to wrap current row before reaching its end.
+    #
+    # === Example
+    # Using basic hierarchy:
+    #  table do
+    #    row do
+    #      cell do
+    #        text "cell 1 in row 1"
+    #      end
+    #      cell do
+    #        text "cell 2 in row 1"
+    #      end
+    #    end
+    #    row do
+    #      cell do
+    #        text "cell 1 in row 2"
+    #      end
+    #      cell do
+    #        text "cell 2 in row 2"
+    #      end
+    #    end
+    #  end
+    #
+    # Using :cols option:
+    #  table :cols => 2 do
+    #    cell do
+    #      text "cell 1 in row 1"
+    #    end
+    #    cell do
+    #      text "cell 2 in row 1"
+    #    end
+    #
+    #    cell do
+    #      text "cell 1 in row 2"
+    #    end
+    #    cell do
+    #      text "cell 2 in row 2"
+    #    end
+    #  end
+    #
+    # === Options
+    # You can use also aliases provided by ElementInterface::OPTIONS_ALIASES in all options +Hash+es.
+    #
+    # [:background]
+    #   Described in BlockElement.
+    # [:border]
+    #   Described in BlockElement.
+    # [:cols]
+    #   Sets number of columns in table structure. If value is given it will automatically sort cells to rows.
+    #
+    #   You can also manually wrap the row by calling row method between cells.
+    #
+    def initialize(options, parent = nil, &block) # :yields: table_element
+      @options = options
+      @parent = parent
+      @elements = []
+      @cells_map = [[]]
+      @map_pos = [0, 0]
+      use_options :margin
+      @cols = options[:cols] ? options[:cols].to_i : nil
+      process self, &block if block
+    end
+
+    private
+    def inner_size
+      unless @size
+        size = [0, 0]
+        # set width of cols and height of rows
+        #   get size of cells
+        [0, 1].each do |dimension|
+          size_key = [:width, :height][dimension]
+          table_key = [:cols, :rows][dimension]
+          sizes = []
+          size_types = []
+          @cells_map.each_with_index do |cells_row, row_index|
+            cells_row.each_with_index do |element, col_index|
+              index = [col_index, row_index][dimension]
+              sizes[index] = {:max => 0, :sum => 0, :count => 0, :percentage => 0, :fixed => 0, :blow_up => false} unless sizes[index]
+              size_types[index] = :dynamic unless size_types[index]
+              size_of_element = element[:obj].final_size[dimension] / element[table_key]
+              sizes[index][:max] = size_of_element if size_of_element > sizes[index][:max]
+              sizes[index][:sum] = sizes[index][:sum] + size_of_element
+              sizes[index][:count] = sizes[index][:count] + 1
+              sizes[index][:percentage] = element[size_key] if element[size_key].class == Float
+              sizes[index][:fixed] = element[size_key] if element[size_key].class == Fixnum
+              sizes[index][:blow_up] = true if element[size_key].class == String
+            end
+          end
+          size[dimension] = @options[size_key] ? @options[size_key] : sizes.map{|s| s[:max]}.inject(:+).to_i
+          #   calculating new size
+          #     first step: sets basically known values
+          sizes.each_with_index do |s, index|
+            if s[:blow_up]
+              sizes[index] = 0
+            elsif s[:fixed] > 0
+              sizes[index] = s[:fixed]
+              size_types[index] = :fixed
+            elsif s[:percentage] > 0
+              sizes[index] = size[dimension] * s[:percentage]
+            elsif !@options[size_key]
+              sizes[index] = s[:max]
+            else
+              sizes[index][:avg] = s[:sum] / s[:count]
+            end
+          end
+          #     second step: resize zero value to all free space (it's 0% effect)
+          remaining_size = nil
+          zeros_count = nil
+          sizes.each_with_index do |s, index|
+            next unless s.class == Fixnum && s == 0
+            remaining_size = [size[dimension] - sizes.map{|siz| siz.is_a?(Hash) ? siz[:avg] : siz }.inject(:+).to_i, 0].max unless remaining_size
+            zeros_count = sizes.select{|siz| siz.class == Fixnum && siz == 0}.size unless zeros_count
+            sizes[index] = remaining_size/zeros_count
+          end
+          #     third step: split free space to remaining cells by average size
+          remaining_size = nil
+          avgs_sum = nil
+          sizes.each_with_index do |s, index|
+            next unless s.is_a? Hash
+            remaining_size = [size[dimension] - sizes.select{|siz| siz.class == Fixnum}.inject(:+).to_i, 0].max unless remaining_size
+            avgs_sum = [sizes.select{|siz| siz.is_a?(Hash)}.map{|siz| siz[:avg]}.inject(:+), 1].max unless avgs_sum
+            sizes[index] = [remaining_size*s[:avg]/avgs_sum, 1].max
+          end
+          #   resize cell
+          @cells_map.each_with_index do |cells_row, row_index|
+            cells_row.each_with_index do |element, col_index|
+              index = [col_index, row_index][dimension]
+              unless element[:is_duplicit]
+                s = sizes[index..index+element[table_key]-1].inject(:+).to_i
+                if dimension == 0
+                  element[:obj].set_width s, (size_types[index] == :fixed)
+                else
+                  element[:obj].set_height s, (size_types[index] == :fixed)
+                end
+              end
+            end
+          end
+        end
+        @size = size
+      end
+      @size
+    end
+
+    def draw(x, y, endless)
+      draw_background x, y
+      draw_border x, y
+      inner_size
+      @elements.each do |element|
+        x_pos = element[:x].class == Proc ? element[:x].call : element[:x]
+        y_pos = element[:y].class == Proc ? element[:y].call : element[:y]
+        element[:obj].draw! x_pos+x, y_pos+y
+      end
+      @drawing = false
+    end
+
+    def add_element(e, options)
+      @size = nil
+      cols = [options[:colspan].to_i, 1].max
+      rows = [options[:rowspan].to_i, 1].max
+      move_to_next_pos
+      on_left_element = @map_pos[0] == 0 ? nil : @cells_map[@map_pos[1]][@map_pos[0]-1]
+      x = on_left_element ? lambda{(on_left_element[:x].class == Proc ? on_left_element[:x].call : on_left_element[:x]) + on_left_element[:obj].final_size[0]} : 0
+      on_top_element = @map_pos[1] == 0 ? nil : @cells_map[@map_pos[1]-1][@map_pos[0]]
+      y = on_top_element ? lambda{(on_top_element[:y].class == Proc ? on_top_element[:y].call : on_top_element[:y]) + on_top_element[:obj].final_size[1]} : 0
+      element = {:x => x, :y => y, :width => options[:width], :height => options[:height], :obj => e, :cols => cols, :rows => rows, :is_duplicit => false}
+      e.set_width(width ? (width * options[:width]).to_i : nil, false) if options[:width].class == Float
+      e.set_height(height ? (height * options[:height]).to_i : nil, false) if options[:height].class == Float
+      @elements << element
+      @map_pos[0].upto(@map_pos[0]+cols-1) do |x|
+        @map_pos[1].upto(@map_pos[1]+rows-1) do |y|
+          @cells_map[y] ||= []
+          @cells_map[y][x] = element
+          unless element[:is_duplicit]
+            element = element.clone
+            element[:is_duplicit] = true
+          end
+        end
+      end
+      e
+    end
+
+    def move_to_next_pos
+      @map_pos[0] = @map_pos[0] + 1 while @cells_map[@map_pos[1]][@map_pos[0]]
+      row if @cols && @map_pos[0] >= @cols
+    end
+
+    public
+    # Creates new TableCellElement as a cell of tables composite. See TableCellElement.new for arguments information.
+    def cell(options = {}, &block) # :yields: cell_element
+      zero_percent = {}
+      zero_percent[:width] = "0%" if options[:width] == "0%"
+      zero_percent[:height] = "0%" if options[:height] == "0%"
+      treat_options options
+      add_element TableCellElement.new(options, self, &block), options.merge(zero_percent)
+    end
+
+    # Creates row of cells and gives block for compositing inner elements in table.
+    #
+    # You can also call it alone to make next cells in new row.
+    def row(&block) # :yields: table_element
+      process self, &block if block
+      if @map_pos[0] > 0
+        @map_pos = [0, @map_pos[1] + 1]
+        @cells_map[@map_pos[1]] ||= []
+        move_to_next_pos
+      end
+      self
+    end
+  end
+end

data/lib/elements/text_element.rb

@@ -0,0 +1,195 @@
+require File.dirname(__FILE__) + '/element_interface.rb'
+
+module DynamicImageElements
+  # Element providing drawing of stylized text. You can use markup language of text specified by http://developer.gnome.org/pango/stable/PangoMarkupFormat.html
+  class TextElement
+    include ElementInterface
+
+    # Text element accepts content as text and options +Hash+. Block can be given and class provides original Pango::Layout object to modify it.
+    #
+    # === Options
+    # Options can contain general attributes specified by BlockElement if it's created by it.
+    # Most of TextElement options are based on Pango::Layout object.
+    #
+    # [:align]
+    #   Alignment of paragraphs. Valid values are :left, :center and :right.
+    # [:auto_dir]
+    #   If true, compute the bidirectional base direction from the layout's contents.
+    # [:color]
+    #   Sets foreground of text element. Accepts value for DynamicImageSources::SourceFactory.
+    # [:crop_to]
+    #   Crop text to reach a specified size. Use an Array or String separated by space chars to provide further arguments.
+    #
+    #   Valid crop_to methods are :letters, :words and :sentences. Default method is :words if no one is given. Sentence is determined by one of ".!?".
+    #
+    #   Add :lines (or :line) as second argument if size is for lines number, not by method. Lines are determined by parent container or :width if it's given. See examples for more details.
+    #
+    #   ==== Examples
+    #   * <tt>:crop_to => 10</tt> will crop text down to 10 words
+    #   * <tt>:crop_to => [10, :letters]</tt> will crop text down to 10 letters and it's same as <tt>:crop => "10 letters"</tt>
+    #   * <tt>:crop_to => [3, :lines]</tt> will crop text down by words to 3 lines
+    #   * <tt>:crop_to => [1, :line, :letters]</tt> will crop text down by letters to 1 line
+    #
+    # [:crop_suffix]
+    #   It's value is added at end of text in case it's cropped. It can be caused by :crop and :to_fit options.
+    # [:font]
+    #   Creates a new font description from a string representation in the form "[FAMILY-LIST] [STYLE-OPTIONS] [SIZE]", where FAMILY-LIST is a comma separated list of families optionally terminated by a comma, STYLE_OPTIONS is a whitespace separated list of words where each WORD describes one of style, variant, weight, or stretch, and SIZE is an decimal number (size in points). Any one of the options may be absent. If FAMILY-LIST is absent, then the family_name field of the resulting font description will be initialized to nil. If STYLE-OPTIONS is missing, then all style options will be set to the default values. If SIZE is missing, the size in the resulting font description will be set to 0. If str is nil, creates a new font description structure with all fields unset.
+    # [:indent]
+    #   Sets the width to indent each paragraph.
+    # [:justify]
+    #   Sets whether or not each complete line should be stretched to fill the entire width of the layout. This stretching is typically done by adding whitespace, but for some scripts (such as Arabic), the justification is done by extending the characters.
+    # [:spacing]
+    #   Sets the amount of spacing between the lines of the layout.
+    # [:to_fit]
+    #   Sets method how to deform text to fit its parent element. You can use an Array or String separated by space chars to provide further arguments.
+    #
+    #   Valid values are :crop and :resize.
+    #
+    #   Further argument for :crop are method of cropping (:letters, :words, :sentences). Default method is :words if no one is given. Sentence is determined by one of ".!?". You can specify text to add at end of text if it's cropped by :crop_suffix.
+    #
+    #   You can combine methods in your own order by setting further method in next positions of Array or String. Stop value must be set between methods to determine when to use next method.
+    #
+    #   ==== Example
+    #   For one method use:
+    #   * <tt>:to_fit => :crop</tt> is same as <tt>:to_fit => [:crop]</tt> and <tt>:to_fit => "crop"</tt>
+    #   * <tt>:to_fit => :resize</tt>
+    #   * <tt>:to_fit => [:crop, :letters]</tt> will crop text by letters to fit its parent container and its same as <tt>:to_fit => "crop letters"</tt>
+    #   For more methods use:
+    #   * <tt>:to_fit => [:crop, 10, :resize]</tt> will crop down to 10 words to fit, if it's not enough it will reduce size of font
+    #   * <tt>:to_fit => [:crop, :letters, 10, :resize]</tt> will crop down to 10 letters to fit, if it's not enough it will reduce size of font
+    #   * <tt>:to_fit => [:resize, 6, :crop]</tt> will reduce size down to 6 pt letters to fit, if it's not enough it will crop words
+    #   * <tt>:to_fit => [:resize, 6, :crop, :letters]</tt> will reduce size down to 6 pt letters to fit, if it's not enough it will crop letters
+    #   * <tt>:to_fit => [:crop, 2, :resize, 8, :crop, :letters]</tt> will crop text down to 2 words, if it's not enough to fit it will resize font down, but only to 8 pt and if it's still not enough it will continue with cropping text by letters
+    #
+    def initialize(content, options, parent, &block) # :yields: pango_layout
+      @content = content
+      @options = options
+      @parent = parent
+      @block = block
+      use_options :margin
+    end
+
+    private
+    # Tolerance of space to drawing because <tt>Pango::Layout</tt> doesn't fix exactly to given size
+    SIZE_TOLERANCE = 0
+    def setup_pango_layout(pango_layout)
+      pango_layout.set_width((@parent.width-@margin[1]-@margin[3]+SIZE_TOLERANCE)*Pango::SCALE) if @parent.width
+      pango_layout.set_font_description Pango::FontDescription.new(@options[:font].to_s) if @options[:font]
+      pango_layout.set_width @options[:width]*Pango::SCALE if @options[:width]
+      pango_layout.set_alignment({:left => Pango::ALIGN_LEFT, :center => Pango::ALIGN_CENTER, :right => Pango::ALIGN_RIGHT}[@options[:align].to_sym]) if @options[:align]
+      pango_layout.set_indent @options[:indent].to_i*Pango::SCALE if @options[:indent] && (@options[:indent].class == Fixnum || @options[:indent].class == Float || @options[:indent].class == String)
+      pango_layout.set_spacing @options[:spacing].to_i*Pango::SCALE if @options[:spacing] && (@options[:spacing].class == Fixnum || @options[:spacing].class == Float || @options[:spacing].class == String)
+      pango_layout.set_justify !!@options[:justify] if @options[:justify]
+      pango_layout.set_auto_dir !!@options[:auto_dir] if @options[:auto_dir]
+      attrs, txt = Pango.parse_markup @content.to_s
+      pango_layout.set_attributes attrs
+      pango_layout.set_text txt
+      #crop_to option
+      if @options[:crop_to]
+        option = @options[:crop_to].is_a?(Array) ? @options[:crop_to].clone.flatten : @options[:crop_to].to_s.downcase.strip.split(/\s+/)
+        stop_value = option.shift.to_i
+        lines_unit = option[0].to_s == 'lines' || option[0].to_s == 'line'
+        option.shift if lines_unit
+        suffix = @options[:crop_suffix].to_s
+        split = /\s+/ #words
+        split = /[\.!\?]+/ if option.first.to_s == "sentences"
+        split = // if option.first.to_s == "letters"
+        count = txt.strip.split(split).size
+        loop do
+          break if (lines_unit && pango_layout.line_count <= stop_value) || txt == suffix
+          break if !lines_unit && count <= stop_value
+          txt = crop txt, option.first
+          count -= 1
+          pango_layout.set_text txt+suffix
+        end
+      end
+      #to_fit option
+      if @options[:to_fit]
+        width = (@options[:width] || (@parent.width ? @parent.width-@margin[1]-@margin[3] : nil)).to_i
+        height = (@parent.height ? @parent.height-@margin[0]-@margin[2] : nil).to_i
+        if width > 0 || height > 0
+          suffix = @options[:crop_suffix].to_s
+          option = @options[:to_fit].is_a?(Array) ? @options[:to_fit].clone.flatten : @options[:to_fit].to_s.downcase.strip.split(/\s+/)
+          methods = [] #it should look like this [:method1, :method2, ..., :methodN]
+          method_args = [] #it should look like this [[arg1, arg2, ..., stop_value1], [arg1, ..., stop_value2], ..., [arg1, ...]]
+          option.each do |opt|
+            if [:crop, :resize].include? opt.to_s.to_sym
+              methods << opt.to_sym
+              method_args << []
+            else
+              method_args.last << opt if method_args.last
+            end
+          end
+          methods.each do |method|
+            case method
+            when :crop
+              split = /\s+/ #words
+              split = /[\.!\?]+/ if method_args.first.first == "sentences"
+              split = // if method_args.first.first == "letters"
+              count = txt.strip.split(split).size
+              while (width > 0 && pango_layout.size[0]/Pango::SCALE > width+SIZE_TOLERANCE || height > 0 && pango_layout.size[1]/Pango::SCALE > height+SIZE_TOLERANCE) && count > method_args.first.last.to_s.to_i
+                txt = crop txt, method_args.first.first
+                count -= 1
+                pango_layout.set_text txt+suffix
+              end
+            when :resize
+              pango_layout.set_font_description Pango::FontDescription.new unless pango_layout.font_description
+              font_size = pango_layout.font_description.size
+              font_size = 13 if font_size.zero?
+              while (width > 0 && pango_layout.size[0]/Pango::SCALE > width+SIZE_TOLERANCE/2 || height > 0 && pango_layout.size[1]/Pango::SCALE > height+SIZE_TOLERANCE/2) && font_size > 1 && font_size > method_args.first.last.to_s.to_i
+                pango_layout.set_font_description pango_layout.font_description.set_size((font_size -= 1)*Pango::SCALE)
+              end
+            end
+            method_args.shift
+          end
+        end
+      end
+      process pango_layout, &@block if @block
+      pango_layout
+    end
+
+    def crop(txt, method)
+      case method.to_s
+      when 'sentences'
+        txt.sub(/([^\.!\?]+|[^\.!\?]+[\.!\?]+)$/, '')
+      when 'letters'
+        txt.sub(/[\S\s]$/, '')
+      else #words
+        txt.sub(/\s*\S+\s*$/, '')
+      end
+    end
+
+    def inner_size
+      unless @size
+        if context
+          pango_layout = context.create_pango_layout
+        else
+          tmp_surface = Cairo::ImageSurface.new 1, 1
+          tmp_context = Cairo::Context.new tmp_surface
+          pango_layout = tmp_context.create_pango_layout
+        end
+        setup_pango_layout pango_layout
+        size = pango_layout.size.map{|i| i/Pango::SCALE}
+        unless context
+          tmp_context.destroy
+          tmp_surface.destroy
+        end
+        @size = size
+      end
+      @size
+    end
+
+    def draw(x, y, endless) #:nodoc:
+      if @options[:color]
+        color_x = x
+        width = nil
+        width = @parent.width-@margin[1]-@margin[3]+SIZE_TOLERANCE if @parent.width
+        width = @options[:width] if @options[:width]
+        color_x = x + (width-inner_size[0])/2 if width
+        @options[:color].set_source *[context, color_x, y, inner_size].flatten
+      end
+      context.move_to x, y
+      context.show_pango_layout setup_pango_layout(context.create_pango_layout)
+    end
+  end
+end