rabbit-qt 0.1.0

data/lib/rabbit/image/base.rb

@@ -0,0 +1,270 @@
+# 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 "forwardable"
+require "digest/sha2"
+
+require "gdk_pixbuf2"
+
+require_relative "../image-data-loader"
+require_relative "../properties"
+require_relative "../utils"
+
+module Rabbit
+  module ImageManipulable
+    class Base
+      extend ModuleLoader
+
+      class << self
+        def delegate
+          extend Forwardable
+
+          def_delegators(:@delegated_loader,
+                         :draw,
+                         :ensure_resize,
+                         :height,
+                         :internal_pixbuf,
+                         :keep_ratio,
+                         :keep_ratio=,
+                         :keep_ratio?,
+                         :original_height,
+                         :original_width,
+                         :pixbuf,
+                         :resize,
+                         :update_size,
+                         :width)
+        end
+      end
+
+      attr_reader :filename
+      attr_reader :properties
+      attr_reader :original_width
+      attr_reader :original_height
+      attr_reader :animation
+
+      def initialize(filename, props, canvas: nil)
+        @filename = filename
+        @properties = Properties.new(props)
+        @canvas = canvas
+        initialize_keep_ratio
+        @animation = nil
+        @animation_iterator = nil
+        @animation_timeout = nil
+        update_size
+        @original_width = @width
+        @original_height = @height
+      end
+
+      def [](key)
+        @properties[key]
+      end
+
+      def []=(key, value)
+        @properties[key] = value
+      end
+
+      def keep_ratio?
+        @properties.keep_ratio
+      end
+      # For backward compatibility
+      alias_method :keep_ratio, :keep_ratio?
+
+      def keep_ratio=(value)
+        @properties.keep_ratio = value
+      end
+
+      def pixbuf
+        @pixbuf
+      end
+
+      def width
+        (relative_clip_width&.resolve(@width) || @width) -
+          (relative_clip_x&.resolve(@width) || 0)
+      end
+
+      def height
+        (relative_clip_height&.resolve(@height) || @height) -
+          (relative_clip_y&.resolve(@height) || 0)
+      end
+
+      def relative_clip_x
+        @properties.get_relative_size("relative_clip_x", @filename)
+      end
+
+      def relative_clip_y
+        @properties.get_relative_size("relative_clip_y", @filename)
+      end
+
+      def relative_clip_width
+        @properties.get_relative_size("relative_clip_width", @filename)
+      end
+
+      def relative_clip_height
+        @properties.get_relative_size("relative_clip_height", @filename)
+      end
+
+      def resize(w, h)
+        return if w.nil? and h.nil?
+
+        if keep_ratio?
+          if w and h.nil?
+            h = (original_height * w.to_f / original_width).ceil
+          elsif w.nil? and h
+            w = (original_width * h.to_f / original_height).ceil
+          end
+        else
+          w ||= width
+          h ||= height
+        end
+        w = w.ceil if w
+        h = h.ceil if h
+        if w and w > 0 and h and h > 0 and [w, h] != [width, height]
+          @width = w
+          @height = h
+        end
+      end
+
+      def draw(canvas, x, y, params={})
+        default_params = default_draw_params(x, y)
+        target_pixbuf = pixbuf
+        if @animation_iterator
+          @animation_iterator.advance
+          target_pixbuf = @animation_iterator.pixbuf
+          update_animation_timeout(canvas)
+        end
+        canvas.draw_pixbuf(target_pixbuf, x, y, default_params.merge(params))
+      end
+
+      private
+      def initialize_keep_ratio
+        return unless @properties["keep_ratio"].nil?
+        # For backward compatibility
+        keep_scale = @properties["keep_scale"]
+        if keep_scale.nil?
+          @properties["keep_ratio"] = true
+        else
+          @properties["keep_ratio"] = keep_scale
+        end
+      end
+
+      def load_data(data)
+        loader = ImageDataLoader.new(data)
+        begin
+          loader.load
+        rescue ImageLoadError
+          raise ImageLoadError.new("#{@filename}: #{$!.message}")
+        end
+
+        @width = loader.width
+        @height = loader.height
+        @pixbuf = loader.pixbuf
+        @animation = loader.animation
+        if @animation and not @animation.static_image?
+          @animation_iterator = @animation.get_iter
+        else
+          @animation_iterator = nil
+        end
+        if @animation_timeout
+          GLib::Source.remove(@animation_timeout)
+          @animation_timeout = nil
+        end
+      end
+
+      def update_animation_timeout(canvas)
+        delay_time = @animation_iterator.delay_time
+        if delay_time > 0 and @animation_timeout.nil?
+          @animation_timeout = GLib::Timeout.add(delay_time) do
+            canvas.redraw
+            @animation_timeout = nil
+            # update_animation_timeout(canvas)
+            GLib::Source::REMOVE
+          end
+        end
+      end
+
+      def default_draw_params(x, y)
+        _relative_clip_x = relative_clip_x
+        _relative_clip_y = relative_clip_y
+        _relative_clip_width = relative_clip_width
+        _relative_clip_height = relative_clip_height
+        if _relative_clip_x or
+           _relative_clip_y or
+           _relative_clip_width or
+           _relative_clip_height
+          clip_x = _relative_clip_x&.resolve(@width) || 0
+          clip_y = _relative_clip_y&.resolve(@height) || 0
+          clip_width = _relative_clip_width&.resolve(@width) || @width
+          clip_height = _relative_clip_height&.resolve(@height) || @height
+          uncliped_width = width - (clip_width - clip_x) + @width
+          uncliped_height = height - (clip_height - clip_y) + @height
+          {
+            width: uncliped_width,
+            height: uncliped_height,
+            clip_x: x + clip_x,
+            clip_y: y + clip_y,
+            clip_width: clip_width,
+            clip_height: clip_height,
+          }
+        else
+          {
+            width: width,
+            height: height,
+          }
+        end
+      end
+
+      # TODO: Move to more suitable location
+      def cache_processed_data(canvas, input, extension)
+        tmp_dir_name = canvas&.tmp_dir_name
+        return yield unless tmp_dir_name
+        hash = compute_hash(input)
+        cached_path = File.join(tmp_dir_name, "#{hash}.#{extension}")
+        unless File.exist?(cached_path)
+          processed_path = yield
+          FileUtils.cp(processed_path, cached_path)
+        end
+        cached_path
+      end
+
+      def compute_hash(input)
+        digest = Digest::SHA2.new
+        add_data = lambda do |data|
+          case data
+          when Array
+            data.each do |element|
+              add_data.call(element)
+            end
+          when Hash
+            data.each do |key, value|
+              add_data.call(key)
+              add_data.call(value)
+            end
+          when String
+            digest << data
+          when IO
+            loop do
+              chunk = data.read(4096)
+              break if chunk.nil?
+              digest << chunk
+            end
+          end
+        end
+        add_data.call(input)
+        digest.hexdigest
+      end
+    end
+  end
+end

data/lib/rabbit/image/default.rb

@@ -0,0 +1,42 @@
+# 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 "base"
+
+module Rabbit
+  module ImageManipulable
+
+    class Default < Base
+
+      push_loader(self)
+
+      class << self
+        def match?(filename)
+          true
+        end
+      end
+
+      private
+      def update_size
+        File.open(@filename, "rb") do |file|
+          Dir.chdir(File.dirname(@filename)) do
+            load_data(file.read)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/image/dia.rb

@@ -0,0 +1,74 @@
+# 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 "base"
+
+module Rabbit
+  module ImageManipulable
+    class Dia < Base
+
+      unshift_loader(self)
+
+      DIA_COMMANDS = %w(dia)
+
+      include SystemRunner
+
+      class << self
+        def match?(filename)
+          return true if File.extname(filename).downcase.end_with?(".dia")
+
+          File.open(filename) do |f|
+            begin
+              first_line = f.gets
+              second_line = f.gets
+              return false unless second_line
+              return false unless first_line.start_with?("<?xml")
+              return false unless second_line.start_with?("<dia:diagram")
+              true
+            rescue EncodingError
+              false
+            end
+          end
+        end
+      end
+
+      delegate
+
+      def initialize(filename, props, canvas: nil)
+        init_delegated_loader(filename, props, canvas)
+        super
+      end
+
+      private
+      def init_delegated_loader(filename, props, canvas)
+        @svg_file = Tempfile.new(["rabbit-image-loader-dia", ".svg"])
+        args = ["--export=#{@svg_file.path}"]
+        args << "--filter=svg"
+        args << filename
+        if DIA_COMMANDS.any? {|dia| run(dia, *args)}
+          @delegated_loader = SVG.new(@svg_file.path, props)
+        else
+          raise DiaCanNotHandleError.new("dia #{args.join(' ')}",
+                                         DIA_COMMANDS)
+        end
+      end
+
+      def load_image
+        # do nothing
+      end
+    end
+  end
+end

data/lib/rabbit/image/eps.rb

@@ -0,0 +1,129 @@
+# 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 "base"
+
+module Rabbit
+  module ImageManipulable
+    class EPS < Base
+
+      unshift_loader(self)
+
+      GS_COMMANDS = %w(gs gswin32c)
+
+      include SystemRunner
+
+      class << self
+        def match?(filename)
+          File.open(filename) do |f|
+            begin
+              f.each_line do |line|
+                case line
+                when /^%!PS-Adobe-\d+.\d+ EPS/i
+                  return true
+                when /^%%/
+                  # ignore
+                else
+                  return false
+                end
+              end
+              false
+            rescue EncodingError, ArgumentError
+              false
+            end
+          end
+        end
+      end
+
+      private
+      def update_size
+        load_image
+      end
+
+      def load_image(width=nil, height=nil)
+        data = begin
+                 eps_to_png(width, height)
+               rescue EPSCanNotHandleError
+                 eps_to_pnm(width, height)
+               end
+        load_data(data)
+      end
+
+      def eps_to_png(width=nil, height=nil)
+        eps_to(width, height, "pngalpha")
+      end
+
+      def eps_to_pnm(width=nil, height=nil)
+        eps_to(width, height, "pnm")
+      end
+
+      def eps_to(width, height, device, *gs_options)
+        x, y, w, h, r = eps_size
+        resolution = (r || Canvas::INTERNAL_DPI).round
+        ratio = resolution.to_f / Canvas::INTERNAL_DPI
+        width = ((width || w) * ratio).round
+        height = ((height || h) * ratio).round
+
+        adjust_eps_if_need(x, y) do |path|
+          tmp = Tempfile.new("rabbit-image-eps")
+          args = %W(-q -dBATCH -dNOPAUSE -sDEVICE=#{device}
+            -sOutputFile=#{tmp.path} -dEPSFitPage
+            -dGraphicsAlphaBits=4 -dTextAlphaBits=4
+            -g#{width}x#{height} -r#{resolution}x#{resolution}
+            #{path})
+          if GS_COMMANDS.any? {|gs| run(gs, *args)}
+            begin
+              tmp.open
+              tmp.binmode
+              tmp.read
+            ensure
+              tmp.close
+            end
+          else
+            raise EPSCanNotHandleError.new("gs #{args.join(' ')}", GS_COMMANDS)
+          end
+        end
+      end
+
+      def eps_size
+        sx, sy, w, h, r = nil
+        File.read(@filename).split(/(?:\r\n?|\n)/).each do |line|
+          if /^%%BoundingBox:\s*/ =~ line
+            next if $POSTMATCH.chomp == '(atend)'
+            sx, sy, ex, ey = $POSTMATCH.scan(/-?\d+/).map{|x| Integer(x)}
+            w, h = ex - sx, ey - sy
+          elsif /^%%Feature:\s*\*Resolution\s*(\d+)dpi/ =~ line
+            r = $1.to_i
+          end
+          break if r and sx and sy and w and h
+        end
+        [sx, sy, w, h, r]
+      end
+
+      def adjust_eps_if_need(x, y)
+        if x and y and x > 0 and y > 0
+          tmp = Tempfile.new("rabbit-loader-adjusted-eps")
+          tmp.puts("#{x} neg #{y} neg translate")
+          tmp.print(File.open(@filename) {|f| f.read})
+          tmp.close
+          yield tmp.path
+        else
+          yield @filename
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/image/gimp.rb

@@ -0,0 +1,69 @@
+# 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 "../utils"
+require_relative "base"
+
+module Rabbit
+  module ImageManipulable
+    class GIMP < Base
+
+      unshift_loader(self)
+
+      GIMP_COMMANDS = %w(gimp)
+      HEADER = "gimp xcf file"
+      HEADER_SIZE = HEADER.size
+
+      include SystemRunner
+
+      class << self
+        def match?(filename)
+          File.open(filename, "rb") do |f|
+            HEADER == f.read(HEADER_SIZE)
+          end
+        end
+      end
+
+      private
+      def update_size
+        png_file = Tempfile.new(["rabbit-loader-gimp-png", ".png"])
+        png_path = png_file.path
+        clip_to_image = 1
+        merge_type = clip_to_image
+        command = <<-COMMAND
+(let ((image (car (gimp-file-load RUN-NONINTERACTIVE
+                                  "#{@filename}" "#{@filename}"))))
+  (gimp-file-save RUN-NONINTERACTIVE image "#{png_path}")
+  (gimp-image-delete image))
+        COMMAND
+        args = [
+          "--no-interface",
+          "--batch-interpreter", "plug-in-script-fu-eval",
+          "--batch", command,
+          "--batch", "(gimp-quit TRUE)",
+        ]
+        if GIMP_COMMANDS.any? {|gimp| run(gimp, *args); File.exist?(png_path)}
+          png_file.open
+          png_file.binmode
+          load_data(png_file.read)
+        else
+          raise GIMPCanNotHandleError.new("gimp #{args.join(' ')}",
+                                          GIMP_COMMANDS)
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/image/mermaid.rb

@@ -0,0 +1,74 @@
+# Copyright (C) 2022-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 "../gettext"
+require_relative "pdf"
+
+module Rabbit
+  module ImageManipulable
+    class Mermaid < Base
+      include GetText
+      include SystemRunner
+
+      unshift_loader(self)
+
+      class << self
+        def match?(filename)
+          File.extname(filename).downcase.end_with?(".mmd")
+        end
+      end
+
+      delegate
+
+      def initialize(filename, props, canvas: nil)
+        init_delegated_loader(filename, props, canvas)
+        super
+      end
+
+      private
+      def init_delegated_loader(filename, props, canvas)
+        background_color = props["background_color"] || "transparent"
+        pdf_path = File.open(filename, "rb") do |source|
+          cache_processed_data(canvas, [source, background_color], "pdf") do
+            @pdf_file = Tempfile.new(["rabbit-image-loader-mermaid", ".pdf"])
+            command_line = [
+              "npx",
+              "--yes",
+              "--package=@mermaid-js/mermaid-cli",
+              "mmdc",
+              "--backgroundColor", background_color,
+              "--input", filename,
+              "--output", @pdf_file.path,
+              "--pdfFit",
+            ]
+            unless SystemRunner.run(*command_line)
+              format = _("tried mermaid command: %s")
+              additional_info = format % command_line.inspect
+              raise MermaidCanNotHandleError.new(command_line.join(' '),
+                                                 additional_info)
+            end
+            @pdf_file.path
+          end
+        end
+        @delegated_loader = PDF.new(pdf_path, props)
+      end
+
+      def load_image
+        # do nothing
+      end
+    end
+  end
+end