rabbit 0.6.2

data/lib/rabbit/element/enum-list.rb

@@ -0,0 +1,33 @@
+require 'rabbit/element/container-element'
+
+module Rabbit
+  module Element
+    class EnumList
+      include ContainerElement
+
+      def to_html(generator)
+        "<ol>\n#{super}\n</ol>"
+      end
+    end
+
+    class EnumListItem
+      include ContainerElement
+      attr_accessor :order
+
+      def to_rd
+        prefix = "(#{order}) "
+        indent = " " * prefix.length
+        first, *rest = text.split(/\n/)
+        rest = rest.collect do |line|
+          "#{indent}#{line}"
+        end.join("\n")
+        "#{prefix}#{first}\n#{rest}".rstrip
+      end
+
+      def to_html(generator)
+        "<li>\n#{super}\n</li>"
+      end
+    end
+  end
+end
+

data/lib/rabbit/element/footnote.rb

@@ -0,0 +1,32 @@
+require 'rabbit/element/text-element'
+require 'rabbit/element/text-container-element'
+
+module Rabbit
+  module Element
+    class FootTextBlock
+      include ContainerElement
+    end
+
+    class Footnote
+      include TextElement
+
+      attr_reader :order
+
+      def initialize(order)
+        @order = order
+        super("")
+      end
+    end
+
+    class FootText
+      include TextContainerElement
+
+      attr_reader :order
+
+      def initialize(order, elems=[])
+        @order = order
+        super(elems)
+      end
+    end
+  end
+end

data/lib/rabbit/element/image-title-slide.rb

@@ -0,0 +1,18 @@
+require 'rabbit/element/title-slide'
+
+module Rabbit
+  module Element
+    class ImageTitleSlide < TitleSlide
+
+      def initialize(image_path, properties=nil)
+        @image_path = image_path
+        properties ||= {:as_large_as_possible => true}
+        super(Element::Image.new(image_path, properties))
+      end
+
+      def theme
+        super || "image-viewer"
+      end
+    end
+  end
+end

data/lib/rabbit/element/image.rb

@@ -0,0 +1,167 @@
+require 'rabbit/image'
+require 'rabbit/element/block-element'
+
+module Rabbit
+  module Element
+    class Image
+      include BlockElement
+      include BlockHorizontalCentering
+
+      alias element_draw draw
+      include ImageManipulable
+      alias image_draw draw
+      alias draw element_draw
+
+      attr_reader :filename
+      attr_reader :caption
+      attr_reader :normalized_width, :normalized_height
+      attr_reader :relative_width, :relative_height
+
+      def initialize(filename, prop)
+        @filename = filename
+        super(filename, prop)
+        %w(caption dither_mode).each do |name|
+          instance_variable_set("@#{name}", prop[name])
+        end
+        %w(keep_scale keep_ratio).each do |name|
+          unless prop[name].nil?
+            self.keep_ratio = true_value?(prop[name])
+          end
+        end
+        %w(as_large_as_possible).each do |name|
+          instance_variable_set("@#{name}", true_value?(prop[name]))
+        end
+        %w(width height
+           x_dither y_dither
+           normalized_width normalized_height
+           relative_width relative_height
+          ).each do |name|
+          begin
+            instance_variable_set("@#{name}", prop[name] && Integer(prop[name]))
+          rescue ArgumentError
+            raise InvalidImageSizeError.new(filename, name, prop[name])
+          end
+        end
+        setup_draw_parameters(prop)
+        resize(@width, @height)
+      end
+
+      def draw_element(canvas, x, y, w, h, simulation)
+        draw_image(canvas, x, y, w, h, simulation)
+      end
+
+      def text
+        @caption.to_s
+      end
+
+      def to_rd
+        text
+      end
+
+      def to_html(generator)
+        src = generator.save_pixbuf(pixbuf, File.basename(@filename))
+        html = "<img "
+        if @caption
+          alt = generator.h(@caption)
+          html << "title=\"#{alt}\" alt=\"#{alt}\" "
+        end
+        html << "src=\"#{src}\" />"
+        html
+      end
+
+      def dither_mode
+        @dither_mode ||= "normal"
+        mode_name = "DITHER_#{@dither_mode.upcase}"
+        if Gdk::RGB.const_defined?(mode_name)
+          Gdk::RGB.const_get(mode_name)
+        else
+          Gdk::RGB::DITHER_NORMAL
+        end
+      end
+
+      def x_dither
+        @x_dither || 0
+      end
+
+      def y_dither
+        @y_dither || 0
+      end
+
+      alias _compile compile
+      def compile_for_horizontal_centering(canvas, x, y, w, h)
+        _compile(canvas, x, y, w, h)
+      end
+
+      def compile(canvas, x, y, w, h)
+        super
+        adjust_size(canvas, @x, @y, @w, @h)
+      end
+
+      def width
+        super + @padding_left + @padding_right
+      end
+
+      def height
+        super + @padding_top + @padding_bottom
+      end
+
+      def as_large_as_possible?
+        @as_large_as_possible
+      end
+
+      private
+      def setup_draw_parameters(prop)
+        @draw_parameters = {}
+        @draw_parameters[:reflect] = {} if true_value?(prop["reflect"])
+        [:ratio, :alpha].each do |key|
+          name = "reflect_#{key}"
+          value = prop[name]
+          next unless value
+          @draw_parameters[:reflect] ||= {}
+          @draw_parameters[:reflect][key] = Float(value)
+        end
+      end
+
+      def draw_image(canvas, x, y, w, h, simulation)
+        unless simulation
+          image_draw(canvas, x, y, @draw_parameters)
+        end
+        [x, y + height, w, h - height]
+      end
+
+      def adjust_size(canvas, x, y, w, h)
+        base_w = w
+        base_h = (@oh || h) - @padding_top - @padding_bottom
+        if @as_large_as_possible
+          iw = base_w - x
+          ih = base_h - y
+          if iw.to_f / original_width > ih.to_f / original_height
+            iw = nil
+          else
+            ih = nil
+          end
+        else
+          nw = make_normalized_size(@normalized_width)
+          nh = make_normalized_size(@normalized_height)
+          rw = make_relative_size(@relative_width, base_w)
+          rh = make_relative_size(@relative_height, base_h)
+          iw = nw || rw
+          ih = nh || rh
+        end
+        resize(iw, ih)
+      end
+
+      def make_normalized_size(size)
+        size && screen_size(size)
+      end
+
+      def make_relative_size(size, parent_size)
+        size && parent_size && ((size / 100.0) * parent_size).ceil
+      end
+
+      def true_value?(value)
+        value == true or value == "true"
+      end
+    end
+  end
+end

data/lib/rabbit/element/index-slide.rb

@@ -0,0 +1,190 @@
+require 'rabbit/canvas'
+require 'rabbit/renderer/pixmap'
+require 'rabbit/element/container-element'
+require 'rabbit/element/slide-element'
+
+module Rabbit
+  module Element
+    class IndexSlide
+      include SlideElement
+
+      ROW_NUMBER = 4
+      COLUMN_NUMBER = 4
+
+      class << self
+        def make_thumbnails(canvas, width, height)
+          maker = make_thumbnail_maker(canvas, width, height)
+          maker.apply_theme(canvas.theme_name) if canvas.theme_name
+
+          canvas.source_force_modified(true) do |source|
+            maker.parse(source)
+          end
+
+          thumbnails = []
+          number_of_slide = maker.slide_size - 1
+          canvas.renderer.pre_to_pixbuf(number_of_slide)
+          canceled = false
+          maker.each_slide_pixbuf do |slide, pixbuf, slide_number|
+            if canvas.renderer.to_pixbufing(slide_number)
+              thumbnails << IndexThumbnail.new(pixbuf,
+                                               maker.slide_title(slide_number),
+                                               slide_number,
+                                               number_of_slide)
+            else
+              canceled = true
+            end
+            !canceled
+          end
+          canvas.renderer.post_to_pixbuf(canceled)
+          maker.quit
+
+          if canceled
+            nil
+          else
+            thumbnails
+          end
+        end
+
+        def make_index_slides(canvas)
+          width = canvas.width.to_f / (COLUMN_NUMBER + 1)
+          height = canvas.height.to_f / (ROW_NUMBER + 1)
+          default_margin_top = (height / (ROW_NUMBER + 1) / 2).ceil
+          default_margin_bottom = default_margin_top
+          default_margin_left = (width / (COLUMN_NUMBER + 1) / 2).ceil
+          default_margin_right = default_margin_left
+
+          thumbnails = make_thumbnails(canvas, width, height)
+          return [] unless thumbnails
+
+          max_per_slide = ROW_NUMBER * COLUMN_NUMBER
+          thumbnail_rows_set = []
+          thumbnails.each_with_index do |thumbnail, slide_number|
+            if slide_number.remainder(max_per_slide).zero?
+              thumbnail_rows_set << []
+            end
+            if slide_number.remainder(ROW_NUMBER).zero?
+              row = IndexThumbnailRow.new
+              row.default_margin_top = default_margin_top
+              row.default_margin_bottom = default_margin_bottom
+              row.default_margin_left = default_margin_left
+              row.default_margin_right = default_margin_right
+              row.clear_theme
+              thumbnail_rows_set.last << row
+            end
+            thumbnail_rows_set.last.last << thumbnail
+          end
+
+          thumbnail_rows_set.collect do |rows|
+            index_slide = new(rows)
+            index_slide.default_margin_top = default_margin_top
+            index_slide.default_margin_bottom = default_margin_bottom
+            index_slide.default_margin_left = default_margin_left
+            index_slide.default_margin_right = default_margin_right
+            index_slide.clear_theme
+            index_slide
+          end
+        end
+
+        private
+        def make_thumbnail_maker(canvas, width, height)
+          new_canvas = Canvas.new(canvas.logger, Renderer::Pixmap)
+          new_canvas.width = width
+          new_canvas.height = height
+          new_canvas.pango_context = canvas.create_pango_context
+          new_canvas.use_gl = canvas.use_gl?
+          def new_canvas.quit
+            nil
+          end
+          new_canvas
+        end
+      end
+
+      def title
+        _("Index")
+      end
+
+      def slide_number(canvas, x, y)
+        column = (COLUMN_NUMBER * (x / canvas.width)).to_i
+        row = (ROW_NUMBER * (y / canvas.height)).to_i
+        thumb = self[row] && self[row][column]
+        if thumb
+          thumb.number
+        else
+          nil
+        end
+      end
+
+      def to_html(generator)
+        "<div class=\"index-slide\">\n#{super}\n</div>"
+      end
+    end
+
+    class IndexThumbnailRow
+      include ContainerElement
+    end
+
+    class IndexThumbnail
+      include Base
+
+      attr_reader :pixbuf, :title, :number, :number_of_slides
+      def initialize(pixbuf, title, number, number_of_slides)
+        @pixbuf = pixbuf
+        @title = title
+        @number = number
+        @number_of_slides = number_of_slides
+        @layout = nil
+        super()
+      end
+
+      def clear_theme
+        super
+        @width = @pixbuf.width
+        @height = @pixbuf.height
+      end
+
+      def draw_element(canvas, x, y, w, h, simulation)
+        width = @pixbuf.width
+        height = @pixbuf.height
+        side_margin = parent.margin_left + parent.margin_right
+        unless simulation
+          if @layout.nil?
+            margin_bottom = parent.margin_bottom
+            text_size = (margin_bottom * Pango::SCALE).ceil
+            text = "#{@number}/#{@number_of_slides}"
+            text = %Q[<span size="#{text_size}">#{text}</span>]
+            @layout, _, _ = canvas.make_layout(text)
+            @layout.set_width(width * Pango::SCALE)
+            @layout.set_alignment(Pango::Layout::ALIGN_CENTER)
+          end
+          canvas.draw_pixbuf(@pixbuf, x, y)
+          canvas.draw_rectangle(false, x, y, width, height)
+          canvas.draw_layout(@layout, x, y + height)
+        end
+        [x + width + side_margin, y, w - width - side_margin, h]
+      end
+
+      def text
+        @title
+      end
+
+      def to_rd
+        "* #{text}"
+      end
+
+      def to_html(generator)
+        number_of_places = generator.number_of_places(@number_of_slides)
+        format = "thumbnail%0#{number_of_places}d"
+        src = generator.save_pixbuf(@pixbuf, format % @number)
+        title = generator.slide_image_title(@number)
+        img = "<img title=\"#{title}\" src=\"#{src}\" />"
+
+        if generator.output_slide_html?
+          href = generator.slide_href(@number)
+          "<a href=\"#{href}\">\n#{img}\n</a>"
+        else
+          img
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/element/item-list.rb

@@ -0,0 +1,31 @@
+require 'rabbit/element/container-element'
+
+module Rabbit
+  module Element
+    class ItemList
+      include ContainerElement
+
+      def to_html(generator)
+        "<ul>\n#{super}\n</ul>"
+      end
+    end
+
+    class ItemListItem
+      include ContainerElement
+
+      def to_rd
+        prefix = "* "
+        indent = " " * prefix.length
+        first, *rest = text.split(/\n/)
+        rest = rest.collect do |line|
+          "#{indent}#{line}"
+        end.join("\n")
+        "#{prefix}#{first}\n#{rest}".rstrip
+      end
+
+      def to_html(generator)
+        "<li>\n#{super}\n</li>"
+      end
+    end
+  end
+end