rabbit-qt 0.1.0

data/lib/rabbit/renderer/engine/qt_painter.rb

@@ -0,0 +1,397 @@
+# Copyright (C) 2025  Rabbit Qt Contributors
+#
+# 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 "cairo"
+require "stringio"
+
+require_relative "../../image-data-loader"
+require_relative "../kernel"
+
+module Rabbit
+  module Renderer
+    module Engine
+      module QtPainter
+        include Kernel
+
+        def background_image=(pixbuf)
+          @background_image_pixbuf = pixbuf
+        end
+
+        def init_renderer(painter)
+          @painter = painter
+          @painters ||= []
+          @painters.push(@painter)
+          @painter.set_render_hint(QPainter::Antialiasing, true)
+          @painter.set_render_hint(QPainter::TextAntialiasing, true)
+          @painter.set_render_hint(QPainter::SmoothPixmapTransform, true)
+        end
+
+        def finish_renderer
+          @painters.pop
+          @painter = @painters.last
+        end
+
+        def init_context(painter)
+          init_renderer(painter)
+        end
+
+        def finish_context
+          finish_renderer
+        end
+
+        def to_gdk_rgb(color)
+          make_color(color).to_a
+        end
+
+        def translate_context(x, y, params={})
+          @painter.translate(x, y)
+        end
+
+        def rotate_context(angle, params={})
+          @painter.rotate(-angle)
+        end
+
+        def scale_context(x, y, params={})
+          @painter.scale(x, y)
+        end
+
+        def reflect_context(base, params={})
+          case base
+          when :y
+            @painter.scale(-1, 1)
+          else
+            @painter.scale(1, -1)
+          end
+        end
+
+        def shear_context(x, y, params={})
+          @painter.shear(x, y)
+        end
+
+        def save_context
+          @painter.save
+          super
+        end
+
+        def restore_context
+          @painter.restore
+        end
+
+        def draw_background(slide)
+          super
+          if @background_image_pixbuf
+            @painter.save
+            qimage = pixbuf_to_qimage(@background_image_pixbuf)
+            brush = QBrush.new(qimage)
+            @painter.fill_rect(0, 0, @painter.device.width, @painter.device.height, brush)
+            @painter.restore
+          end
+        end
+
+        def draw_line(x1, y1, x2, y2, color=nil, params={})
+          x1, y1 = from_screen(x1, y1)
+          x2, y2 = from_screen(x2, y2)
+          @painter.save
+          setup_pen(color, params)
+          @painter.draw_line(x1, y1, x2, y2)
+          @painter.restore
+        end
+
+        def draw_rectangle(filled, x, y, w, h, color=nil, params={})
+          x, y = from_screen(x, y)
+          @painter.save
+          qcolor = make_color(color).to_qcolor
+          if filled
+            @painter.set_pen(::Qt::NoPen)
+            @painter.set_brush(QBrush.new(qcolor))
+            @painter.draw_rect(x, y, w, h)
+          else
+            setup_pen(color, params)
+            @painter.set_brush(::Qt::NoBrush)
+            @painter.draw_rect(x, y, w, h)
+          end
+          @painter.restore
+        end
+
+        def draw_rounded_rectangle(filled, x, y, w, h, radius,
+                                   color=nil, params={})
+          x, y = from_screen(x, y)
+          x_radius = params[:x_radius] || radius
+          y_radius = params[:y_radius] || radius
+          @painter.save
+          qcolor = make_color(color).to_qcolor
+          if filled
+            @painter.set_pen(::Qt::NoPen)
+            @painter.set_brush(QBrush.new(qcolor))
+          else
+            setup_pen(color, params)
+            @painter.set_brush(::Qt::NoBrush)
+          end
+          @painter.draw_rounded_rect(x, y, w, h, x_radius, y_radius)
+          @painter.restore
+        end
+
+        def draw_arc(filled, x, y, w, h, a1, a2, color=nil, params={})
+          r = w * 0.5
+          draw_arc_by_radius(filled, x + w * 0.5, y + h * 0.5,
+                             r, a1, a2, color, params)
+        end
+
+        def draw_arc_by_radius(filled, x, y, r, a1, a2, color=nil, params={})
+          x, y = from_screen(x, y)
+          # Qt uses 1/16th degree units for arc drawing
+          start_angle = (a1 * 16).to_i
+          span_angle = (a2 * 16).to_i
+          rect_x = (x - r).to_i
+          rect_y = (y - r).to_i
+          rect_w = (r * 2).to_i
+          rect_h = (r * 2).to_i
+          @painter.save
+          qcolor = make_color(color).to_qcolor
+          if filled
+            @painter.set_pen(::Qt::NoPen)
+            @painter.set_brush(QBrush.new(qcolor))
+            @painter.draw_pie(rect_x, rect_y, rect_w, rect_h,
+                              start_angle, span_angle)
+          else
+            setup_pen(color, params)
+            @painter.set_brush(::Qt::NoBrush)
+            @painter.draw_arc(rect_x, rect_y, rect_w, rect_h,
+                              start_angle, span_angle)
+          end
+          @painter.restore
+        end
+
+        def draw_lines(points, color=nil, params={})
+          draw_polygon(false, points, color, params.merge({:opened => true}))
+        end
+
+        def draw_polygon(filled, points, color=nil, params={})
+          return if points.empty?
+          qt_points = points.map {|x, y| from_screen(x, y)}
+          @painter.save
+          qcolor = make_color(color).to_qcolor
+          if filled
+            @painter.set_pen(::Qt::NoPen)
+            @painter.set_brush(QBrush.new(qcolor))
+          else
+            setup_pen(color, params)
+            @painter.set_brush(::Qt::NoBrush)
+          end
+          polygon = QPolygon.new
+          qt_points.each {|x, y| polygon.append(QPoint.new(x.to_i, y.to_i))}
+          unless params[:opened]
+            first = qt_points.first
+            polygon.append(QPoint.new(first[0].to_i, first[1].to_i))
+          end
+          if filled
+            @painter.draw_polygon(polygon)
+          else
+            @painter.draw_polyline(polygon)
+          end
+          @painter.restore
+        end
+
+        def draw_layout(layout, x, y, color=nil, params={})
+          return unless layout
+          x, y = from_screen(x, y)
+          @painter.save
+          qcolor = make_color(color).to_qcolor
+          @painter.set_pen(qcolor)
+          # Render Pango layout to Cairo ImageSurface, then convert to QImage
+          ink_rect, logical_rect = layout.extents
+          # Use the larger of ink and logical extents to avoid clipping
+          ink_w = (ink_rect.width / Pango::SCALE).ceil
+          ink_h = (ink_rect.height / Pango::SCALE).ceil
+          ink_x = (ink_rect.x / Pango::SCALE).floor
+          ink_y = (ink_rect.y / Pango::SCALE).floor
+          log_w = (logical_rect.width / Pango::SCALE).ceil
+          log_h = (logical_rect.height / Pango::SCALE).ceil
+          # Surface must cover both logical and ink extents
+          sw = [log_w, ink_x + ink_w].max + 2
+          sh = [log_h, ink_y + ink_h].max + 2
+          if sw > 0 && sh > 0
+            surface = ::Cairo::ImageSurface.new(::Cairo::FORMAT_ARGB32, sw, sh)
+            cr = ::Cairo::Context.new(surface)
+            cr.set_source_rgba(*make_color(color).to_a)
+            cr.show_pango_layout(layout)
+            cr.destroy
+            qimage = cairo_surface_to_qimage(surface)
+            @painter.draw_image(x.to_i, y.to_i, qimage)
+          end
+          @painter.restore
+        end
+
+        def draw_pixbuf(pixbuf, x, y, params={})
+          x, y = from_screen(x, y)
+          width = (params[:width] || pixbuf.width).to_f
+          height = (params[:height] || pixbuf.height).to_f
+          @painter.save
+          apply_clip_qt(x, y, pixbuf.width, pixbuf.height, params)
+          qimage = pixbuf_to_qimage(pixbuf)
+          if width.to_i != pixbuf.width || height.to_i != pixbuf.height
+            scaled = qimage.scaled(width.to_i, height.to_i,
+                                   ::Qt::IgnoreAspectRatio,
+                                   ::Qt::SmoothTransformation)
+            @painter.draw_image(x.to_i, y.to_i, scaled)
+          else
+            @painter.draw_image(x.to_i, y.to_i, qimage)
+          end
+          @painter.restore
+        end
+
+        def draw_rsvg_handle(handle, x, y, params={})
+          x, y = from_screen(x, y)
+          dim = handle.dimensions
+          w = dim.width
+          h = dim.height
+          width = (params[:width] || w).to_f
+          height = (params[:height] || h).to_f
+          # Render via Cairo to an image surface
+          surface = ::Cairo::ImageSurface.new(::Cairo::FORMAT_ARGB32,
+                                              width.to_i, height.to_i)
+          cr = ::Cairo::Context.new(surface)
+          cr.scale(width / w, height / h)
+          cr.render_rsvg_handle(handle)
+          cr.destroy
+          @painter.save
+          apply_clip_qt(x, y, width, height, params)
+          qimage = cairo_surface_to_qimage(surface)
+          @painter.draw_image(x.to_i, y.to_i, qimage)
+          @painter.restore
+        end
+
+        def draw_poppler_page(page, x, y, params={})
+          x, y = from_screen(x, y)
+          w, h = page.size
+          width = (params[:width] || w).to_f
+          height = (params[:height] || h).to_f
+          # Render via Cairo to an image surface
+          surface = ::Cairo::ImageSurface.new(::Cairo::FORMAT_ARGB32,
+                                              width.to_i, height.to_i)
+          cr = ::Cairo::Context.new(surface)
+          cr.scale(width / w, height / h)
+          cr.render_poppler_page(page)
+          cr.destroy
+          @painter.save
+          apply_clip_qt(x, y, width, height, params)
+          qimage = cairo_surface_to_qimage(surface)
+          @painter.draw_image(x.to_i, y.to_i, qimage)
+          @painter.restore
+        end
+
+        def draw_link(uri)
+          # Qt doesn't have a built-in link annotation in QPainter
+          yield
+        end
+
+        def make_layout(text)
+          attrs, text = Pango.parse_markup(text)
+          layout = create_pango_layout(text)
+          layout.set_attributes(attrs)
+          layout
+        end
+
+        def create_pango_context
+          context = Pango::CairoFontMap.default.create_context
+          set_font_resolution(context)
+          context
+        end
+
+        def create_pango_layout(text)
+          context = create_pango_context
+          layout = Pango::Layout.new(context)
+          layout.text = text
+          layout
+        end
+
+        def set_font_resolution(context)
+          context.resolution = @canvas.font_resolution
+        end
+
+        private
+        def setup_pen(color, params={})
+          qcolor = make_color(color).to_qcolor
+          pen = QPen.new(qcolor)
+          line_width = params[:line_width] || 1
+          pen.set_width_f(line_width)
+          case params[:line_cap]
+          when :round, :butt, :square
+            pen.set_cap_style(::Qt::RoundCap) if params[:line_cap] == :round
+            pen.set_cap_style(::Qt::FlatCap) if params[:line_cap] == :butt
+            pen.set_cap_style(::Qt::SquareCap) if params[:line_cap] == :square
+          else
+            pen.set_cap_style(::Qt::RoundCap)
+          end
+          case params[:line_join]
+          when :round, :miter, :bevel
+            pen.set_join_style(::Qt::RoundJoin) if params[:line_join] == :round
+            pen.set_join_style(::Qt::MiterJoin) if params[:line_join] == :miter
+            pen.set_join_style(::Qt::BevelJoin) if params[:line_join] == :bevel
+          else
+            pen.set_join_style(::Qt::RoundJoin)
+          end
+          if params[:dash]
+            pen.set_dash_pattern(params[:dash].first)
+          end
+          @painter.set_pen(pen)
+        end
+
+        def from_screen(x, y)
+          [x.to_f, y.to_f]
+        end
+
+        def pixbuf_to_qimage(pixbuf)
+          # ruby-qt6's QImage constructor doesn't accept raw pixel data.
+          # Convert pixbuf → PNG temp file → QImage(filename).
+          ensure_tmp_dir
+          path = File.join(@_qt_tmp_dir, "pixbuf.png")
+          pixbuf.save(path, "png")
+          QImage.new(path)
+        end
+
+        def cairo_surface_to_qimage(surface)
+          surface.flush
+          # ruby-qt6's QImage constructor doesn't accept raw pixel data.
+          # Convert Cairo surface → PNG temp file → QImage(filename).
+          ensure_tmp_dir
+          path = File.join(@_qt_tmp_dir, "cairo.png")
+          surface.write_to_png(path)
+          QImage.new(path)
+        end
+
+        def ensure_tmp_dir
+          return if @_qt_tmp_dir
+          require "tmpdir"
+          @_qt_tmp_dir = Dir.mktmpdir("rabbit-qt-")
+          at_exit { FileUtils.rm_rf(@_qt_tmp_dir) if @_qt_tmp_dir }
+        end
+
+        def apply_clip_qt(x, y, w, h, params)
+          clip_x = params[:clip_x]
+          clip_y = params[:clip_y]
+          clip_width = params[:clip_width]
+          clip_height = params[:clip_height]
+          if clip_x || clip_y || clip_width || clip_height
+            @painter.set_clip_rect(x, y,
+                                   clip_width || w,
+                                   clip_height || h)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/renderer/engine.rb

@@ -0,0 +1,18 @@
+# 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 "engine/cairo"
+require_relative "engine/qt_painter"

data/lib/rabbit/renderer/kernel.rb

@@ -0,0 +1,233 @@
+# 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 "../pango-markup"
+
+module Rabbit
+  module Renderer
+    module Kernel
+      def translate_context(x, y, params={})
+      end
+
+      def rotate_context(angle, params={})
+      end
+
+      def scale_context(x, y, params={})
+      end
+
+      def reflect_context(base, params={})
+      end
+
+      def shear_context(x, y, params={})
+      end
+
+      def save_context
+        if block_given?
+          begin
+            yield
+          ensure
+            restore_context
+          end
+        end
+      end
+
+      def restore_context
+      end
+
+      def draw_slide(slide, simulation)
+        unless simulation
+          save_context
+          draw_background(slide)
+        end
+        yield
+      ensure
+        restore_context unless simulation
+      end
+
+      def draw_background(slide)
+        draw_rectangle(true, 0, 0, width, height, @background)
+      end
+
+      def draw_circle(filled, x, y, w, h, color=nil, params={})
+        draw_arc(filled, x, y, w, h, 0, 360, color, params)
+      end
+
+      def draw_circle_by_radius(filled, x, y, r, color=nil, params={})
+        draw_arc_by_radius(filled, x, y, r, 0, 360, color, params)
+      end
+
+      def draw_flag(x, y, pole_height, params)
+        if params["flag_type"] == "triangle"
+          draw_triangle_flag(x, y, pole_height, params)
+        else
+          draw_rectangle_flag(x, y, pole_height, params)
+        end
+      end
+
+      def draw_triangle_flag(x, y, pole_height, params)
+        params = setup_flag_params(pole_height, 1.5, params)
+
+        layout = params["layout"]
+        text_width = params["text_width"]
+        text_height = params["text_height"]
+        pole_width = params["pole_width"]
+        pole_color = params["pole_color"]
+        flag_height = params["flag_height"]
+        flag_width = params["flag_width"]
+        flag_color = params["flag_color"]
+        flag_frame_width = params["flag_frame_width"]
+        flag_frame_color = params["flag_frame_color"]
+
+        draw_rectangle(true, x, y, pole_width, pole_height, pole_color)
+
+        base_x = x + pole_width
+        draw_polygon(true,
+                     [
+                       [base_x, y],
+                       [base_x + flag_width, y + flag_height / 2],
+                       [base_x, y + flag_height],
+                     ],
+                     flag_frame_color)
+        draw_polygon(true,
+                     [
+                       [base_x, y + flag_frame_width],
+                       [
+                         base_x + flag_width - 2 * flag_frame_width,
+                         y + flag_height / 2
+                       ],
+                       [
+                         base_x,
+                         y + flag_height - flag_frame_width
+                       ],
+                     ],
+                     flag_color)
+
+        if layout
+          args = [
+            layout, x, y, pole_width, flag_width * 0.8,
+            text_height, flag_height,
+          ]
+          draw_flag_layout(*args)
+        end
+      end
+
+      def draw_rectangle_flag(x, y, pole_height, params)
+        params = setup_flag_params(pole_height, 1.3, params)
+
+        layout = params["layout"]
+        text_width = params["text_width"]
+        text_height = params["text_height"]
+        pole_width = params["pole_width"]
+        pole_color = params["pole_color"]
+        flag_height = params["flag_height"]
+        flag_width = params["flag_width"]
+        flag_color = params["flag_color"]
+        flag_frame_width = params["flag_frame_width"]
+        flag_frame_color = params["flag_frame_color"]
+
+        draw_rectangle(true, x, y, pole_width, pole_height, pole_color)
+
+        base_x = x + pole_width
+        draw_rectangle(true,
+                       base_x,
+                       y,
+                       flag_width,
+                       flag_height,
+                       flag_frame_color)
+        draw_rectangle(true,
+                       base_x,
+                       y + flag_frame_width,
+                       flag_width - flag_frame_width,
+                       flag_height - 2 * flag_frame_width,
+                       flag_color)
+
+        if layout
+          args = [
+            layout, x, y, pole_width, flag_width - 2 * flag_frame_width,
+            text_height, flag_height,
+          ]
+          draw_flag_layout(*args)
+        end
+      end
+
+      def draw_flag_layout(layout, x, y, pole_width, flag_width,
+                           text_height, flag_height)
+        base_x = x + pole_width
+        layout.width = flag_width * Pango::SCALE
+        layout.alignment = Pango::Alignment::CENTER
+        base_y = y
+        if text_height < flag_height
+          base_y += (flag_height - text_height) / 2
+        end
+        draw_layout(layout, base_x, base_y)
+      end
+
+      def flag_size(pole_height, params)
+        params = setup_flag_params(pole_height, 1.5, params)
+        [params["pole_width"] + params["flag_width"], pole_height]
+      end
+
+      def gl_supported?
+        false
+      end
+
+      def z_far
+        100.0
+      end
+
+      def z_view
+        5.0
+      end
+
+      private
+      def setup_flag_params(pole_height, default_flag_width_ratio, params)
+        params = params.dup
+
+        text = params["text"]
+        text_attrs = params["text_attributes"] || {}
+        if text
+          markupped_text = PangoMarkup.new("span", text_attrs, text)
+          layout = make_layout(markupped_text.to_s)
+          text_width, text_height = layout.pixel_size
+          params["layout"] = layout
+          params["text_width"] = text_width
+          params["text_height"] = text_height
+          flag_width_default = [
+            text_width * default_flag_width_ratio,
+            pole_height / 2
+          ].max
+          flag_height_default = [text_height, flag_width_default].max
+        else
+          params["layout"] = nil
+          flag_width_default = flag_height_default = nil
+        end
+
+        params["pole_width"] = params["pole_width"] || 2
+        params["pole_color"] ||= "black"
+        flag_height = params["flag_height"] ||
+          flag_height_default || pole_height / 2
+        flag_height = [flag_height, pole_height].min
+        params["flag_height"] = flag_height
+        params["flag_width"] ||= flag_width_default || flag_height
+        params["flag_color"] ||= "red"
+        params["flag_frame_width"] ||= params["pole_width"]
+        params["flag_frame_color"] ||= params["pole_color"]
+
+        params
+      end
+    end
+  end
+end