rabbit 0.6.2

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

@@ -0,0 +1,229 @@
+require 'gtk2'
+
+require 'rabbit/renderer/kernel'
+
+module Rabbit
+  module Renderer
+    module Engine
+      module GDK
+        include Kernel
+
+        class << self
+          def priority
+            0
+          end
+        end
+
+        def prepare_renderer(drawable)
+          @gdk_drawables ||= []
+          @gdk_drawable = drawable
+          @gdk_drawables.push(@gdk_drawable)
+        end
+
+        def init_renderer(drawable)
+          prepare_renderer(drawable)
+        end
+
+        def finish_renderer
+          @gdk_drawables.pop
+          @gdk_drawable = @gdk_drawables.pop
+        end
+
+        def alpha_available?
+          false
+        end
+
+        def foreground=(color)
+          @foreground.set_rgb_fg_color(color.to_gdk_color)
+        end
+
+        def background=(color)
+          @background.set_rgb_fg_color(color.to_gdk_color)
+        end
+
+        def background_image=(pixbuf)
+          w, h = pixbuf.width, pixbuf.height
+          pixmap = Gdk::Pixmap.new(nil, w, h, depth)
+          pixmap.draw_rectangle(@background, true, 0, 0, w, h)
+          args = [
+                  @foreground, pixbuf,
+                  0, 0, 0, 0, w, h,
+                  Gdk::RGB::DITHER_NORMAL, 0, 0,
+                 ]
+          pixmap.draw_pixbuf(*args)
+          @background.set_tile(pixmap)
+          @background.fill = Gdk::GC::Fill::TILED
+        end
+
+        def draw_line(x1, y1, x2, y2, color=nil, params={})
+          gc = make_gc(color, params)
+          return if gc.nil?
+          @gdk_drawable.draw_line(gc, x1, y1, x2, y2)
+        end
+
+        def draw_lines(points, color=nil, params={})
+          gc = make_gc(color, params)
+          return if gc.nil?
+          @gdk_drawable.draw_lines(gc, points)
+        end
+
+        def draw_rectangle(filled, x, y, w, h, color=nil, params={})
+          gc = make_gc(color, params)
+          return if gc.nil?
+          @gdk_drawable.draw_rectangle(gc, filled, x, y, w, h)
+        end
+
+        def draw_rounded_rectangle(filled, x, y, w, h, radius, color=nil, params={})
+          x_radius = params[:x_radius] || radius
+          y_radius = params[:y_radius] || radius
+          x_diameter = x_radius * 2
+          y_diameter = y_radius * 2
+
+          line_width = params[:line_width]
+
+          inner_x = x + x_radius
+          inner_y = y + y_radius
+          inner_w = w - x_diameter
+          inner_h = h - y_diameter
+
+          if filled
+            draw_rectangle(true, inner_x, inner_y, inner_w, inner_h, color)
+          end
+
+          if filled
+            top = [inner_x, y, inner_w, y_radius]
+            left = [x, inner_y, x_radius, inner_h]
+            bottom = [inner_x, inner_y + inner_h, inner_w, y_radius]
+            right = [inner_x + inner_w, inner_y, x_radius, inner_h]
+
+            [top, left, bottom, right].each do |rx, ry, rw, rh|
+              draw_rectangle(true, rx, ry, rw, rh, color)
+            end
+          else
+            top = [inner_x, y, inner_x + inner_w, y]
+            left = [x, inner_y, x, inner_y + inner_h]
+            bottom = [inner_x, y + h, inner_x + inner_w, y + h]
+            right = [x + w, inner_y, x + w, inner_y + inner_h]
+            [top, left, bottom, right].each do |start_x, start_y, end_x, end_y|
+              draw_line(start_x, start_y, end_x, end_y, color,
+                        {:line_width => line_width})
+            end
+          end
+
+          upper_left = [x, y, 90]
+          lower_left = [x, y + inner_h, 180]
+          lower_right = [x + inner_w, y + inner_h, 270]
+          upper_right = [x + inner_w, y, 0]
+          [
+           upper_left, lower_left,
+           lower_right, upper_right
+          ].each do |ax, ay, start_angle|
+            draw_arc(filled, ax, ay, x_diameter, y_diameter,
+                     start_angle, 90, color, {:line_width => line_width})
+          end
+        end
+
+        def draw_arc(filled, x, y, w, h, a1, a2, color=nil, params={})
+          gc = make_gc(color, params)
+          return if gc.nil?
+          a1 *= 64
+          a2 *= 64
+          @gdk_drawable.draw_arc(gc, filled, x, y, w, h, a1, a2)
+        end
+
+        def draw_arc_by_radius(filled, x, y, r, a1, a2, color=nil, params={})
+          sx = x - r
+          sy = y - r
+          w = r * 2
+          h = r * 2
+          draw_arc(filled, sx, sy, w, h, a1, a2, color, params)
+        end
+
+        def draw_polygon(filled, points, color=nil, params={})
+          gc = make_gc(color, params)
+          return if gc.nil?
+          @gdk_drawable.draw_polygon(gc, filled, points)
+        end
+
+        def draw_layout(layout, x, y, color=nil, params={})
+          gc = make_gc(color, params)
+          return if gc.nil?
+          @gdk_drawable.draw_layout(gc, x, y, layout)
+        end
+
+        def draw_pixbuf(pixbuf, x, y, params={})
+          gc = make_gc(params[:color], params)
+          return if gc.nil?
+
+          draw_scaled_pixbuf = params[:draw_scaled_pixbuf]
+          width = params[:width] || pixbuf.width
+          height = params[:height] || pixbuf.height
+          if draw_scaled_pixbuf and
+              [width, height] != [pixbuf.width, pixbuf.height]
+            pixbuf = pixbuf.scale(width, height)
+          end
+          args = [0, 0, x, y,
+                  width, height,
+                  params[:dither_mode] || Gdk::RGB::DITHER_NORMAL,
+                  params[:x_dither] || 0,
+                  params[:y_dither] || 0]
+          @gdk_drawable.draw_pixbuf(gc, pixbuf, *args)
+        end
+
+        private
+        def init_engine_color
+          @foreground = Gdk::GC.new(@gdk_drawable)
+          @background = make_gc_from_string(@background_color)
+        end
+
+        # this method is no longer need. the reason that
+        # this isn't removed is only for my memo.
+        def set_mask(gc, x, y, mask)
+          clip_mask = gc.clip_mask
+          clip_origin = gc.clip_origin
+          gc.clip_mask = mask
+          gc.set_clip_origin(x, y)
+          result = yield(gc)
+          gc.clip_mask = clip_mask
+          gc.set_clip_origin(*clip_origin)
+          result
+        end
+
+        def internal_make_gc(color)
+          if color.nil?
+            Gdk::GC.new(@gdk_drawable)
+          elsif color.is_a?(String)
+            make_gc_from_string(color)
+          elsif color.is_a?(Gdk::Color)
+            make_gc_from_gdk_color(color)
+          elsif color.is_a?(Renderer::Color)
+            make_gc_from_gdk_color(color.to_gdk_color)
+          else
+            color
+          end
+        end
+
+        def make_gc_from_gdk_color(color)
+          gc = Gdk::GC.new(@gdk_drawable)
+          gc.set_rgb_fg_color(color)
+          gc
+        end
+
+        def make_gc_from_string(str)
+          color = Color.parse(str).to_gdk_color
+          make_gc_from_gdk_color(color)
+        end
+
+        def make_gc(color, params={})
+          return nil if params[:pattern] and color.nil?
+          gc = internal_make_gc(color)
+          gc.set_line_attributes(get_line_width(params, 1),
+                                 Gdk::GC::LINE_SOLID,
+                                 Gdk::GC::CAP_ROUND,
+                                 Gdk::GC::JOIN_ROUND)
+          gc
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/renderer/gl.rb

@@ -0,0 +1,176 @@
+require "gtkglext"
+
+require "rabbit/rabbit"
+Rabbit.add_gui_init_proc do
+  Gtk::GL.init
+end
+
+require "rabbit/trackball"
+
+module Rabbit
+  module Renderer
+    module GL
+      def draw_slide(slide, simulation, &block)
+        if gl_available?
+          gl_drawable.gl_begin(gl_context) do
+            init_gl_drawing_info
+            super(slide, simulation, &block)
+            gl_drawable.swap_buffers if gl_drawable.double_buffered?
+          end
+        else
+          super(slide, simulation, &block)
+        end
+      end
+
+      def draw_cube(filled, x, y, z, size, color=nil, &block)
+        return super unless gl_available?
+        draw_gl(x, y, z, color, block) do
+          ::Gdk::GL.draw_cube(filled, size)
+        end
+      end
+
+      def draw_sphere(filled, x, y, z, radius, slices, stacks,
+                      color=nil, &block)
+        return super unless gl_available?
+        draw_gl(x, y, z, color, block) do
+          ::Gdk::GL.draw_sphere(filled, radius, slices, stacks)
+        end
+      end
+
+      def draw_cone(filled, x, y, z, base, height, slices, stacks,
+                    color=nil, &block)
+        return super unless gl_available?
+        draw_gl(x, y, z, color, block) do
+          ::Gdk::GL.draw_cone(filled, base, height, slices, stacks)
+        end
+      end
+
+      def draw_torus(filled, x, y, z, inner_radius, outer_radius,
+                     n_sides, rings, color=nil, &block)
+        return super unless gl_available?
+        draw_gl(x, y, z, color, block) do
+          ::Gdk::GL.draw_torus(filled, inner_radius,
+                             outer_radius, n_sides, rings)
+        end
+      end
+
+      def draw_tetrahedron(filled, x, y, z, color=nil, &block)
+        return super unless gl_available?
+        draw_gl(x, y, z, color, block) do
+          ::Gdk::GL.draw_tetrahedron(filled)
+        end
+      end
+
+      def draw_octahedron(filled, x, y, z, color=nil, &block)
+        return super unless gl_available?
+        draw_gl(x, y, z, color, block) do
+          ::Gdk::GL.draw_octahedron(filled)
+        end
+      end
+
+      def draw_dodecahedron(filled, x, y, z, color=nil, &block)
+        return super unless gl_available?
+        draw_gl(x, y, z, color, block) do
+          ::Gdk::GL.draw_dodecahedron(filled)
+        end
+      end
+
+      def draw_icosahedron(filled, x, y, z, color=nil, &block)
+        return super unless gl_available?
+        draw_gl(x, y, z, color, block) do
+          ::Gdk::GL.draw_icosahedron(filled)
+        end
+      end
+
+      def draw_teapot(filled, x, y, z, scale, color=nil, &block)
+        return super unless gl_available?
+        draw_gl(x, y, z, color, block) do
+          ::Gdk::GL.draw_teapot(filled, scale)
+        end
+      end
+
+      def gl_compile(id)
+        return super unless gl_available?
+        ::GL.NewList(id, ::GL::COMPILE)
+        yield
+        ::GL.EndList
+      end
+
+      def gl_call_list(id, x, y, z, color=nil, &block)
+        return super unless gl_available?
+        draw_gl(x, y, z, color, block) do
+          ::GL.CallList(id)
+        end
+      end
+
+      def gl_supported?
+        (Gtk::GL::BUILD_VERSION <=> [1, 2, 0]) >= 0
+      end
+
+      private
+      def init_gl_drawing_info
+        gl_drawable.wait_gdk
+        ::GL.ClearDepth(1.0)
+        ::GL.Clear(::GL::DEPTH_BUFFER_BIT)
+
+        ::GL.Viewport(0, 0, width, height)
+
+        ::GL.Light(::GL::LIGHT0, ::GL::POSITION, [1.0, 1.0, 1.0, 0.0])
+        ::GL.Enable(::GL::LIGHTING)
+        ::GL.Enable(::GL::LIGHT0)
+        ::GL.Enable(::GL::DEPTH_TEST)
+
+        ::GL.MatrixMode(::GL::PROJECTION)
+        ::GL.LoadIdentity
+        GLU.Perspective(30.0, width / height, 1.0, z_far)
+
+        ::GL.MatrixMode(::GL::MODELVIEW)
+        ::GL.LoadIdentity
+        GLU.LookAt(0.0, 0.0, z_view,
+                   0.0, 0.0, 0.0,
+                   0.0, 1.0, 0.0)
+        ::GL.Translate(0.0, 0.0, -z_view)
+        ::GL.Scale(gl_scale, gl_scale, gl_scale)
+        ::GL.MultMatrix(gl_quaternion.build_rotmatrix)
+        gl_drawable.wait_gl
+      end
+
+      def draw_gl(x, y, z, color, block)
+        gl_drawable.wait_gdk
+        ::GL.PushMatrix
+        setup_geometry(x, y, z)
+        setup_color(color)
+        block.call(true) if block
+        yield
+        block.call(false) if block
+        unless gl_drawable.double_buffered?
+          ::GL.Flush
+        end
+        ::GL.PopMatrix
+        gl_drawable.wait_gl
+      end
+
+      def setup_color(color)
+        color = make_color(color)
+        ::GL.Light(::GL::LIGHT0, ::GL::DIFFUSE, color.to_a)
+      end
+
+      def setup_geometry(x, y, z)
+        new_x = to_gl_size(x, width)
+        new_y = to_gl_size(height - y, height)
+        new_z = z
+        ::GL.MatrixMode(::GL::MODELVIEW)
+        ::GL.Translate(new_x, new_y, new_z)
+      end
+
+      def to_gl_size(value, max)
+        min = 0.0
+        range = min.abs + max.abs
+        gl_min = -1.0
+        gl_max = 1.0
+        gl_range = gl_min.abs + gl_max.abs
+        (value / range.to_f) * gl_range + gl_min
+      end
+    end
+  end
+end

data/lib/rabbit/renderer/kernel.rb

@@ -0,0 +1,256 @@
+require "rabbit/renderer/color"
+
+module Rabbit
+  module Renderer
+    module Kernel
+      def rsvg_available?
+        false
+      end
+
+      def poppler_available?
+        false
+      end
+
+      def make_color(color)
+        return color if color.is_a?(Color)
+        if color.nil?
+          @foreground
+        else
+          Color.parse(color)
+        end
+      end
+
+      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::Layout::ALIGN_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 draw_cube(filled, x, y, z, size, color=nil)
+        not_support_method("draw_cube")
+      end
+      
+      def draw_sphere(filled, x, y, z, radius, slices, stacks, color=nil)
+        not_support_method("draw_sphere")
+      end
+      
+      def draw_cone(filled, x, y, z, base, height, slices, stacks, color=nil)
+        not_support_method("draw_cone")
+      end
+      
+      def draw_torus(filled, x, y, z, inner_radius, outer_radius,
+                     n_sides, rings, color=nil)
+        not_support_method("draw_torus")
+      end
+      
+      def draw_tetrahedron(filled, x, y, z, color=nil)
+        not_support_method("draw_tetrahedron")
+      end
+      
+      def draw_octahedron(filled, x, y, z, color=nil)
+        not_support_method("draw_octahedron")
+      end
+      
+      def draw_dodecahedron(filled, x, y, z, color=nil)
+        not_support_method("draw_dodecahedron")
+      end
+      
+      def draw_icosahedron(filled, x, y, z, color=nil)
+        not_support_method("draw_icosahedron")
+      end
+      
+      def draw_teapot(filled, x, y, z, scale, color=nil)
+        not_support_method("draw_teapot")
+      end
+
+      def gl_compile(id)
+        not_support_method("gl_compile")
+      end
+
+      def gl_call_list(id, x, y, z, color=nil)
+        not_support_method("gl_call_list")
+      end
+
+      def gl_supported?
+        false
+      end
+
+      def z_far
+        100.0
+      end
+
+      def z_view
+        5.0
+      end
+
+      def new_list_id
+        @list_id += 1
+        @list_id
+      end
+
+      private
+      def get_line_width(params, default=nil)
+        params[:line_width] || default
+      end
+
+      def set_font_resolution(context)
+        context.resolution = @canvas.font_resolution
+      end
+    end
+  end
+end