rabbit 0.6.2

data/lib/rabbit/renderer/display/drawing-area-primitive.rb

@@ -0,0 +1,219 @@
+require 'gtk2'
+
+require "rabbit/utils"
+require "rabbit/renderer/engine"
+require "rabbit/renderer/display/base"
+require 'rabbit/renderer/display/cursor'
+require 'rabbit/renderer/display/gl'
+
+module Rabbit
+  module Renderer
+    module Display
+      module DrawingAreaPrimitive
+        include Base
+
+        include Cursor
+        include GL
+
+        attr_accessor :filename
+        def initialize(canvas)
+          super
+          @filename = nil
+          clear_compiled_slides
+          init_drawing_area
+        end
+
+        def attach_to(window)
+          init_gl(@area)
+          super
+        end
+
+        def detach
+          finalize_gl
+          super
+        end
+
+        def widget
+          @area
+        end
+
+        def clear_slide
+          super
+          clear_compiled_slide
+          redraw
+        end
+
+        def post_fullscreen
+          update_cursor(:blank, true)
+          clear_compiled_slides
+        end
+
+        def post_unfullscreen
+          update_menu
+        end
+
+        def post_iconify
+        end
+
+        def post_apply_theme
+          clear_compiled_slides
+          queue_draw
+        end
+
+        def post_move(old_index, index)
+          queue_draw
+        end
+
+        def post_move_in_slide(old_index, index)
+          queue_draw
+        end
+
+        def pre_parse
+        end
+
+        def post_parse
+          clear_compiled_slides
+        end
+
+        def pre_toggle_index_mode
+        end
+
+        def post_toggle_index_mode
+          queue_draw
+        end
+
+        def pre_to_pixbuf(slide_size)
+        end
+
+        def to_pixbufing(i)
+          true
+        end
+
+        def post_to_pixbuf(canceled)
+        end
+
+        def index_mode_on
+          keep_cursor(:index)
+          update_cursor(nil, true)
+        end
+
+        def index_mode_off
+          restore_cursor(:index)
+        end
+
+        def display?
+          true
+        end
+
+        private
+        def init_dpi
+          @x_dpi = ScreenInfo.screen_x_resolution
+          @y_dpi = ScreenInfo.screen_y_resolution
+        end
+
+        def init_drawing_area
+          @area = Gtk::DrawingArea.new
+          @area.can_focus = true
+          set_map
+          set_expose_event
+          set_configure_event_after
+        end
+
+        def depth
+          @area.window.depth
+        end
+
+        def set_map
+          @area.signal_connect_after("map") do |widget|
+            mapped(widget)
+          end
+        end
+
+        def mapped(widget)
+          @drawable = widget.window
+          prepare_renderer(@drawable)
+        end
+
+        def set_expose_event
+          @area.signal_connect("expose_event") do |widget, event|
+            init_renderer(@drawable)
+            result = exposed(widget, event)
+            finish_renderer
+            result
+          end
+        end
+
+        def exposed(widget, event)
+          draw_current_slide
+          true
+        end
+
+        def draw_current_slide
+          slide = @canvas.current_slide
+          if slide
+            begin
+              compile_slide(slide) unless compiled_slide?(slide)
+              slide.draw(@canvas, false)
+            rescue
+              @canvas.logger.warn($!)
+            end
+          end
+        end
+
+        def set_configure_event_after
+          @area.signal_connect_after("configure_event") do |widget, event|
+            configured_after(widget, event)
+          end
+        end
+
+        def configured_after(widget, event)
+          reload_theme if @drawable
+          false
+        end
+
+        def reload_theme(&callback)
+          callback ||= Utils.process_pending_events_proc
+          @canvas.activate("ReloadTheme", &callback)
+        end
+
+        def clear_compiled_slide(slide=nil)
+          @compiled_slides.delete(slide || @canvas.current_slide)
+        end
+
+        def clear_compiled_slides
+          @compiled_slides = {}
+        end
+
+        def compiled_slide?(slide)
+          @compiled_slides.has_key?(slide)
+        end
+
+        def compile_slide(slide)
+          @compiled_slides[slide] = true
+          slide.draw(@canvas, true)
+        end
+
+        def grab
+          Gtk.grab_add(@area)
+          Gdk.pointer_grab(@area.window, false,
+                           Gdk::Event::BUTTON_PRESS_MASK |
+                           Gdk::Event::BUTTON_RELEASE_MASK |
+                           Gdk::Event::SCROLL_MASK |
+                           Gdk::Event::POINTER_MOTION_MASK,
+                           nil, nil,
+                           Gdk::Event::CURRENT_TIME)
+        end
+
+        def ungrab
+          Gtk.grab_remove(@area)
+          Gdk.pointer_ungrab(Gdk::Event::CURRENT_TIME)
+        end
+
+        def pointer
+          window, x, y, mask = @area.window.pointer
+          [x, y, mask]
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/renderer/display/drawing-area-view-only.rb

@@ -0,0 +1,33 @@
+require 'rabbit/renderer/engine'
+require 'rabbit/renderer/display/drawing-area-primitive'
+
+module Rabbit
+  module Renderer
+    module Display
+      class DrawingAreaViewOnly
+        include Renderer::Engine.renderer_module
+        include DrawingAreaPrimitive
+
+        def attach_to(window)
+          super
+          @window.add(@area)# if @window # need?
+        end
+
+        def detach
+          @window.remove(@area)# if @window # need?
+          super
+        end
+
+        def draw_pixbuf(pixbuf, x, y, params={})
+          super(pixbuf, x, y, {:draw_scaled_pixbuf => true}.merge(params))
+        end
+
+        private
+        def init_color
+          super
+          init_engine_color
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/renderer/display/drawing-area.rb

@@ -0,0 +1,31 @@
+require 'rabbit/renderer/engine'
+require 'rabbit/renderer/display/drawing-area-base'
+require 'rabbit/renderer/display/comment'
+
+module Rabbit
+  module Renderer
+    module Display
+      class DrawingArea
+        include Renderer::Engine.renderer_module
+        include DrawingAreaBase
+        include Comment
+
+        class << self
+          def priority
+            100
+          end
+        end
+
+        def draw_pixbuf(pixbuf, x, y, params={})
+          super(pixbuf, x, y, {:draw_scaled_pixbuf => true}.merge(params))
+        end
+
+        private
+        def init_color
+          super
+          init_engine_color
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/renderer/display/gesture.rb

@@ -0,0 +1,94 @@
+require "rabbit/gesture/handler"
+
+module Rabbit
+  module Renderer
+    module Display
+      module Gesture
+        def initialize(*args, &block)
+          super
+          init_gesture
+        end
+
+        private
+        def init_gesture
+          @gesture = Rabbit::Gesture::Handler.new
+
+          pressed_info = nil
+          target_button = 3
+          target_event_type = Gdk::Event::Type::BUTTON_PRESS
+          target_info = [target_button, target_event_type]
+
+          add_button_press_hook do |event|
+            pressed_info = [event.button, event.event_type]
+            if pressed_info == target_info and event.state.to_i.zero?
+              x, y, w, h = widget.allocation.to_a
+              @gesture.start(target_button, x + event.x, y + event.y, x, y)
+            end
+            false
+          end
+
+          add_button_release_hook do |event, last_button_press_event|
+            pressed_info = nil
+            if @gesture.processing? and event.button == target_button
+              restore_cursor(:gesture) if @gesture.moved?
+              queue_draw
+              moved = @gesture.moved?
+              @gesture.button_release(event.x, event.y, width, height)
+              moved
+            else
+              false
+            end
+          end
+
+          add_motion_notify_hook do |event|
+            if @gesture.processing? and pressed_info == target_info
+              unless @gesture.moved?
+                keep_cursor(:gesture)
+                update_cursor(:hand)
+              end
+              first_move = !@gesture.moved?
+              handled = @gesture.button_motion(event.x, event.y, width, height)
+              queue_draw if handled or first_move
+              init_renderer(@drawable)
+              @gesture.draw_last_locus(self)
+              finish_renderer
+              true
+            else
+              false
+            end
+          end
+        end
+
+        def init_gesture_actions
+          @gesture.clear_actions
+          bg_proc = Utils.process_pending_events_proc
+          add_gesture_action(%w(R), "Next")
+          add_gesture_action(%w(R L), "LastSlide")
+          add_gesture_action(%w(L), "Previous")
+          add_gesture_action(%w(L R), "FirstSlide")
+          add_gesture_action(%w(U), "Quit")
+
+          add_gesture_action(%w(D), "ToggleIndexMode", &bg_proc)
+          add_gesture_action(%w(D U), "ToggleFullScreen", &bg_proc)
+          add_gesture_action(%w(LR), "ToggleGraffitiMode")
+
+          add_gesture_action(%w(UL), "Redraw")
+          add_gesture_action(%w(UL D), "ReloadTheme", &bg_proc)
+        end
+
+        def add_gesture_action(sequence, action, &block)
+          @gesture.add_action(sequence, @canvas.action(action), &block)
+        end
+
+        def gesturing?
+          @gesture.processing?
+        end
+
+        def draw_gesture
+          @gesture.draw(self) if gesturing? and @gesture.moved?
+        end
+      end
+    end
+  end
+end
+

data/lib/rabbit/renderer/display/gl.rb

@@ -0,0 +1,98 @@
+begin
+  require "rabbit/renderer/gl"
+rescue LoadError
+end
+
+module Rabbit
+  module Renderer
+    module Display
+      module GL
+        include Renderer::GL if defined?(Renderer::GL)
+
+        private
+        def init_gl(widget)
+          return unless gl_available?
+          init_gl_event
+          init_gl_capability(widget)
+        end
+
+        def init_gl_event
+          begin_x = nil
+          begin_y = nil
+          start_time = nil
+          handled = false
+          view_scale_max = 2.0
+          view_scale_min = 0.5
+
+          add_button_press_hook do |event|
+            handled = false
+            start_time = event.time
+            begin_x = event.x
+            begin_y = event.y
+            false
+          end
+
+          add_motion_notify_hook do |event|
+            state = event.state
+            if state.button2_mask?
+              handled = true
+              processed = true
+              x = event.x.to_f
+              y = event.y.to_f
+              w = width.to_f
+              h = height.to_f
+
+              if state.control_mask?
+                scale = gl_scale * (1.0 + (y - begin_y) / h)
+                scale = [view_scale_min, scale].max
+                self.gl_scale = [scale, view_scale_max].min
+              elsif state.shift_mask?
+                d_quat = TrackBall.trackball((2.0 * begin_x - w) / w,
+                                             (h - 2.0 * begin_y) / h,
+                                             (2.0 * x - w) / w,
+                                             (h - 2.0 * y) / h)
+                quat = TrackBall.add_quats(d_quat, gl_quaternion)
+                self.gl_quaternion = quat
+              else
+                processed = false
+              end
+
+              if processed and event.time > start_time + 100
+                redraw
+                start_time = event.time
+              end
+            end
+            false
+          end
+
+          add_button_release_hook do |event, last_button_press_event|
+            redraw if handled
+            handled
+          end
+        end
+
+        def init_gl_capability(widget)
+          mode = ::Gdk::GLConfig::MODE_RGBA
+          mode |= ::Gdk::GLConfig::MODE_DEPTH
+          # gl_config = ::Gdk::GLConfig.new(mode | ::Gdk::GLConfig::MODE_DOUBLE)
+          gl_config = ::Gdk::GLConfig.new(mode)
+          widget.set_gl_capability(gl_config)
+          @gl_widget = widget
+        end
+
+        def finalize_gl
+          @gl_widget = nil
+        end
+
+        def gl_drawable
+          @gl_widget.gl_drawable
+        end
+
+        def gl_context
+          @gl_widget.gl_context
+        end
+      end
+    end
+  end
+end
+