rabbit-qt 0.1.0

data/lib/rabbit/element/image.rb

@@ -0,0 +1,292 @@
+# Copyright (C) 2004-2021  Sutou Kouhei <kou@cozmixng.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+require_relative "../image"
+require_relative "block-element"
+
+module Rabbit
+  module Element
+    class Image
+      include Base
+      include BlockElement
+      include BlockHorizontalCentering
+
+      alias element_draw draw
+      include ImageManipulable
+      alias image_draw draw
+      alias draw element_draw
+
+      def initialize(filename, props, canvas: nil)
+        super(filename, props, canvas: canvas)
+        setup_draw_parameters
+        resize(properties.get_size("width", @filename),
+               properties.get_size("height", @filename))
+      end
+
+      def draw_element(canvas, x, y, w, h, simulation)
+        result = draw_image(canvas, x, y, w, h, simulation)
+        draw_properties(canvas, x, y, w, h) unless simulation
+        result
+      end
+
+      def caption
+        self["caption"]
+      end
+
+      def caption_font_size
+        properties.get_float("caption-font-size")
+      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 relative_width
+        properties.get_relative_size("relative_width", @filename)
+      end
+
+      def relative_height
+        properties.get_relative_size("relative_height", @filename)
+      end
+
+      def relative_margin_top
+        properties.get_relative_size("relative_margin_top", @filename)
+      end
+
+      def relative_margin_bottom
+        properties.get_relative_size("relative_margin_bottom", @filename)
+      end
+
+      def relative_margin_left
+        properties.get_relative_size("relative_margin_left", @filename)
+      end
+
+      def relative_margin_right
+        properties.get_relative_size("relative_margin_right", @filename)
+      end
+
+      def relative_padding_top
+        properties.get_relative_size("relative_padding_top", @filename)
+      end
+
+      def relative_padding_bottom
+        properties.get_relative_size("relative_padding_bottom", @filename)
+      end
+
+      def relative_padding_left
+        properties.get_relative_size("relative_padding_left", @filename)
+      end
+
+      def relative_padding_right
+        properties.get_relative_size("relative_padding_right", @filename)
+      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
+
+      alias_method :width_without_padding, :width
+      def width
+        super + @padding_left + @padding_right
+      end
+
+      alias_method :height_without_padding, :height
+      def height
+        super + @padding_top + @padding_bottom
+      end
+
+      def as_large_as_possible?
+        properties.get_boolean("as_large_as_possible")
+      end
+
+      def setup_scene_element(canvas, scene_widget, x, y, w, h)
+        x, y, w, h = super
+        case @loader
+        when ImageManipulable::PDF, ImageManipulable::Mermaid
+          # Render by ourselves
+        else
+          if @loader.animation and not @loader.animation.static_image?
+            texture = Gdk::PixbufAnimationPaintable.new(@loader.animation)
+          else
+            texture = Gdk::Texture.new(@loader.pixbuf)
+          end
+          picture_widget = Gtk::Picture.new(texture)
+          scene_widget.put(picture_widget, x, y, @loader.width, @loader.height)
+          y += @loader.height
+          h -= @loader.height
+        end
+
+        [x, y, w, h]
+      end
+
+      def scene_snapshot_element(widget, snapshot, canvas, x, y, w, h)
+        case @loader
+        when ImageManipulable::PDF, ImageManipulable::Mermaid
+          image_draw(canvas, x, y, @draw_parameters)
+        end
+        y += @loader.height
+        h -= @loader.height
+        [x, y, w, h]
+      end
+
+      private
+      def setup_draw_parameters
+        @draw_parameters = {}
+
+        @draw_parameters[:reflect] = {} if properties.get_boolean("reflect")
+        [:ratio, :alpha].each do |key|
+          name = "reflect_#{key}"
+          value = self[name]
+          next unless value
+          @draw_parameters[:reflect] ||= {}
+          @draw_parameters[:reflect][key] = Float(value)
+        end
+
+        alpha = self["alpha"]
+        @draw_parameters[:alpha] = Float(alpha) if alpha
+      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_margin(w, h)
+        @margin_top =
+          relative_margin_top&.resolve(h) || @margin_top
+        @margin_bottom =
+          relative_margin_bottom&.resolve(h) || @margin_bottom
+        @margin_left =
+          relative_margin_left&.resolve(w) || @margin_left
+        @margin_right =
+          relative_margin_right&.resolve(w) || @margin_right
+      end
+
+      def adjust_padding(w, h)
+        @padding_top =
+          relative_padding_top&.resolve(h) || @padding_top
+        @padding_bottom =
+          relative_padding_bottom&.resolve(h) || @padding_bottom
+        @padding_left =
+          relative_padding_left&.resolve(w) || @padding_left
+        @padding_right =
+          relative_padding_right&.resolve(w) || @padding_right
+      end
+
+      def adjust_size(canvas, x, y, w, h)
+        base_w = w
+        base_h = @oh || h
+        adjust_margin(base_w, base_h)
+        adjust_padding(base_w, base_h)
+        base_h = base_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
+          iw = relative_width&.resolve(base_w)
+          ih = relative_height&.resolve(base_h)
+        end
+        resize(iw, ih)
+      end
+
+      def draw_properties(canvas, base_x, base_y, base_w, base_h)
+        properties.draws.each do |type, *args|
+          case type
+          when "line"
+            if args.last.is_a?(Hash)
+              params = args.pop
+            else
+              params = nil
+            end
+            points = args.each_slice(2).collect do |x, y|
+              x = (x * width_without_padding) + base_x
+              y = (y * height_without_padding) + base_y
+              [x, y]
+            end
+            params = normalize_params(params)
+            color = params.delete(:color) || "black"
+            canvas.draw_lines(points, color, params)
+          when "rectangle"
+            filled, x, y, w, h, params = args
+            x = (x * width_without_padding) + base_x
+            y = (y * height_without_padding) + base_y
+            w = (w * width_without_padding)
+            h = (h * height_without_padding)
+            params = normalize_params(params)
+            color = params.delete(:color) || "black"
+            canvas.draw_rectangle(filled, x, y, w, h, color, params)
+          when "text"
+            text, x, y, params = args
+            params = normalize_params(params)
+            layout = canvas.make_layout(markup_text(text, params))
+            x = (x * width_without_padding) + base_x
+            y = (y * height_without_padding) + base_y
+            color = params.delete(:color) || "black"
+            canvas.draw_layout(layout, x, y, color, params)
+          end
+        end
+      end
+
+      def normalize_params(params)
+        return {} if params.nil?
+        normalized_params = {}
+        params.each do |key, value|
+          normalized_params[key.to_sym] = value
+        end
+        normalized_params
+      end
+
+      def markup_text(text, props)
+        props.each do |name, value|
+          formatter_name = Utils.to_class_name(name.to_s)
+          next unless Format.const_defined?(formatter_name)
+          formatter = Format.const_get(formatter_name).new(value)
+          next unless formatter.text_formatter?
+          text = formatter.format(text)
+        end
+        text
+      end
+    end
+  end
+end

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

@@ -0,0 +1,206 @@
+# Copyright (C) 2006-2025  Sutou Kouhei <kou@cozmixng.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+require_relative "../canvas"
+require_relative "../renderer/offscreen"
+require_relative "container-element"
+require_relative "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 = []
+          n_slides = maker.n_slides - 1
+          canvas.renderer.pre_to_pixbuf(n_slides)
+          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,
+                                               n_slides)
+            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(Renderer::Offscreen)
+          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, :n_slides
+      def initialize(pixbuf, title, number, n_slides)
+        @pixbuf = pixbuf
+        @title = title
+        @number = number
+        @n_slides = n_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}/#{@n_slides}"
+            text = %Q[<span size="#{text_size}">#{text}</span>]
+            @layout, _, _ = canvas.make_layout(text)
+            @layout.set_width(width * Pango::SCALE)
+            @layout.set_alignment(Pango::Alignment::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(@n_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,50 @@
+# Copyright (C) 2004-2025  Sutou Kouhei <kou@cozmixng.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+require_relative "container-element"
+require_relative "block-element"
+
+module Rabbit
+  module Element
+    class ItemList
+      include ContainerElement
+      include BlockElement
+
+      def to_html(generator)
+        "<ul>\n#{super}\n</ul>"
+      end
+    end
+
+    class ItemListItem
+      include ContainerElement
+      include BlockElement
+
+      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

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

@@ -0,0 +1,66 @@
+# Copyright (C) 2004-2025  Sutou Kouhei <kou@cozmixng.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+require_relative "container-element"
+require_relative "text-block-element"
+
+module Rabbit
+  module Element
+    class MethodList
+      include ContainerElement
+    end
+
+    class MethodListItem
+      include ContainerElement
+
+      attr_reader :term, :description
+
+      def initialize(term, description)
+        super()
+        @term = term
+        @description = description
+        add_element(@term)
+        add_element(@description)
+      end
+
+      def name
+        @term.name
+      end
+    end
+
+    class MethodTerm
+      include TextBlockElement
+
+      attr_accessor :name
+    end
+
+    class MethodName
+      include TextContainerElement
+    end
+
+    class ClassName
+      include TextContainerElement
+    end
+
+    class MethodKind
+      include TextContainerElement
+    end
+
+    class MethodDescription
+      include ContainerElement
+    end
+  end
+end

data/lib/rabbit/element/poppler-page.rb

@@ -0,0 +1,52 @@
+# Copyright (C) 2007-2025  Sutou Kouhei <kou@cozmixng.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+require_relative "block-element"
+
+module Rabbit
+  module Element
+    class PopplerPage
+      include Base
+      include BlockElement
+      include BlockHorizontalCentering
+
+      def initialize(page)
+        @page = page
+        super()
+      end
+
+      def draw_element(canvas, x, y, w, h, simulation)
+        unless simulation
+          canvas.draw_poppler_page(@page, x, y, :width => w, :height => h)
+        end
+        [x, y + height, w, h - height]
+      end
+
+      def title
+        text.split(/\r?\n/, 2).first
+      end
+
+      def text
+        @page.text
+      end
+
+      def clear_theme
+        super
+        @width, @height = @page.size
+      end
+    end
+  end
+end