rabbit 0.6.2

data/lib/rabbit/front.rb

@@ -0,0 +1,238 @@
+require "monitor"
+
+require "rabbit/rabbit"
+require "rabbit/utils"
+
+module Rabbit
+
+  class Front
+
+    module PublicLevel
+      STRICT = 0
+      MOVE = 1 << 0
+      READ_SIZE = 1 << 1
+      CHANGE_SIZE = 1 << 2
+      SIZE = READ_SIZE | CHANGE_SIZE
+      READ_SOURCE = 1 << 3
+      CHANGE_SOURCE = 1 << 4
+      SOURCE = READ_SOURCE | CHANGE_SOURCE
+      CONTROL = 1 << 5
+      ALL = MOVE | SIZE | SOURCE | CONTROL
+    end
+
+    AVAILABLE_INTERFACES = []
+
+    %w(move_to_first move_to_last
+       move_to_next_if_can move_to_next_slide_if_can
+       move_to_previous_if_can move_to_previous_slide_if_can
+       move_to_if_can).each do |name|
+      AVAILABLE_INTERFACES << [name, PublicLevel::MOVE, false]
+    end
+
+    %w(width height paper_width paper_height).each do |name|
+      AVAILABLE_INTERFACES << [name, PublicLevel::READ_SIZE, false]
+    end
+
+    %w(width= height= paper_width= paper_height=).each do |name|
+      AVAILABLE_INTERFACES << [name, PublicLevel::CHANGE_SIZE, true]
+    end
+
+    %w(source).each do |name|
+      AVAILABLE_INTERFACES << [name, PublicLevel::READ_SOURCE, false]
+    end
+
+    %w(source= reset).each do |name|
+      AVAILABLE_INTERFACES << [name, PublicLevel::CHANGE_SOURCE, true]
+    end
+
+    %w(toggle_fullscreen toggle_index_mode toggle_whiteout
+       toggle_blackout quit).each do |name|
+      AVAILABLE_INTERFACES << [name, PublicLevel::CONTROL, false]
+    end
+
+    include MonitorMixin
+    
+    attr_reader :image_type, :public_level, :last_modified
+    
+    def initialize(canvas, public_level=nil)
+      super()
+      @canvas = canvas
+      @image_type = "png"
+      @public_level = public_level || PublicLevel::STRICT
+      @previous_width = @canvas.width
+      @previous_height = @canvas.height
+      setup_public_interface
+      clean
+    end
+
+    def current_slide_image
+      update_images_if_need
+      @images[@canvas.current_index]
+    end
+
+    def current_slide_text
+      slide = @canvas.current_slide
+      slide ? slide.text : ""
+    end
+
+    def current_slide_rd
+      slide = @canvas.current_slide
+      slide ? slide.to_rd : ""
+    end
+
+    def title
+      @canvas.title
+    end
+
+    def slide_title
+      @canvas.slide_title
+    end
+    
+    def total_slide_number
+      @canvas.slide_size
+    end
+
+    def current_slide_number
+      @canvas.current_index
+    end
+
+    def first_slide?
+      @canvas.first_slide?
+    end
+
+    def have_next_slide?
+      @canvas.have_next_slide?
+    end
+
+    def have_previous_slide?
+      @canvas.have_previous_slide?
+    end
+
+    def last_slide?
+      @canvas.last_slide?
+    end
+
+    def available_interfaces
+      AVAILABLE_INTERFACES.collect do |name, level, need_clear_cache|
+        [name, level, @canvas.method(name).arity]
+      end
+    end
+
+    def version
+      VERSION
+    end
+
+    def accept_move?
+      not (@public_level & Front::PublicLevel::MOVE).zero?      
+    end
+
+    def append_comment(comment)
+      @canvas.append_comment(comment)
+    end
+    
+    def comments
+      @canvas.comments
+    end
+
+    private
+    def check_dirty
+      mon_synchronize do
+        _check_dirty
+      end
+    end
+
+    def _check_dirty
+      if dirty?
+        clean
+        if off_screen_canvas.need_reload_source?
+          off_screen_canvas.reload_source
+          synchronize
+        end
+      end
+    end
+    
+    def update_images_if_need
+      mon_synchronize do
+        _check_dirty
+        index = @canvas.current_index
+        if @images[index].nil?
+          prev_size = [@previous_width, @previous_height]
+          current_size = [@canvas.width, @canvas.height]
+          if prev_size != current_size
+            off_screen_canvas.reload_theme
+          end
+          pixbuf = off_screen_canvas.to_pixbuf(index)
+          @images[index] = pixbuf.save_to_buffer(@image_type)
+          synchronize
+        end
+      end
+    end
+
+    def dirty?
+      @dirty or
+        @last_modified < @canvas.last_modified or
+        off_screen_canvas.need_reload_source?
+    end
+
+    def synchronize
+      @last_modified = @canvas.last_modified
+      @previous_width = @canvas.width
+      @previous_height = @canvas.height
+    end
+
+    def setup_public_interface
+      AVAILABLE_INTERFACES.each do |name, level, need_clear_cache|
+        arg_list = []
+        arg_list.concat(Utils.arg_list(@canvas.method(name).arity))
+        arg_str = arg_list.join(", ")
+        
+        if (@public_level & level).zero?
+          instance_eval(<<-EOS, __FILE__, __LINE__ + 1)
+            def self.#{name}(#{arg_str})
+              raise NotAvailableInterfaceError.new(#{name.to_s.dump})
+            end
+          EOS
+        else
+          send_arguments = [name.to_s.dump, *arg_list].join(', ')
+          dirty_source = nil
+          dirty_source = "dirty!" if need_clear_cache
+          if (level & PublicLevel::CONTROL).zero?
+            instance_eval(<<-EOS, __FILE__, __LINE__ + 1)
+              def self.#{name}(#{arg_str})
+                result = @canvas.__send__(#{send_arguments})
+                #{dirty_source}
+                result
+              end
+            EOS
+          else
+            instance_eval(<<-EOS, __FILE__, __LINE__ + 1)
+              def self.#{name}(#{arg_str})
+                GLib::Idle.add do
+                  @canvas.__send__(#{send_arguments})
+                  #{dirty_source}
+                  false
+                end
+                true
+              end
+            EOS
+          end
+        end
+      end
+    end
+    
+    def clean
+      @off_screen_canvas = nil
+      @dirty = false
+      @images = []
+      @last_modified = @canvas.last_modified
+    end
+
+    def dirty!
+      @dirty = true
+    end
+
+    def off_screen_canvas
+      @off_screen_canvas ||= @canvas.off_screen_canvas
+    end
+  end
+end

data/lib/rabbit/gesture/handler.rb

@@ -0,0 +1,232 @@
+require 'gtk2'
+
+require 'rabbit/rabbit'
+require 'rabbit/renderer/engine'
+require 'rabbit/gesture/processor'
+
+module Rabbit
+  module Gesture
+    class Handler
+      DEFAULT_BACK_COLOR = Renderer::Color.parse("#3333337f")
+      DEFAULT_LINE_COLOR = Renderer::Color.parse("#f00f")
+      DEFAULT_NEXT_COLOR = Renderer::Color.parse("#0f0c")
+      DEFAULT_CURRENT_COLOR = Renderer::Color.parse("#f0fc")
+
+      DEFAULT_LINE_WIDTH = 3
+      DEFAULT_NEXT_WIDTH = 10
+
+      attr_accessor :back_color, :line_color, :next_color, :current_color
+      attr_accessor :line_width, :next_width
+      def initialize(conf={})
+        super()
+        conf ||= {}
+        @back_color = conf[:back_color] || DEFAULT_BACK_COLOR
+        @line_color = conf[:line_color] || DEFAULT_LINE_COLOR
+        @next_color = conf[:next_color] || DEFAULT_NEXT_COLOR
+        @current_color = conf[:current_color] || DEFAULT_CURRENT_COLOR
+        @line_width = conf[:line_width] || DEFAULT_LINE_WIDTH
+        @next_width = conf[:next_width] || DEFAULT_NEXT_WIDTH
+        @processor = Processor.new(conf[:threshold],
+                                   conf[:skew_threshold_angle])
+        @actions = []
+        @locus = []
+      end
+
+      def processing?
+        @processor.started?
+      end
+
+      def clear_actions
+        @actions.clear
+      end
+
+      def add_action(sequence, action, &block)
+        invalid_motion = sequence.find do |motion|
+          not @processor.available_motion?(motion)
+        end
+        raise InvalidMotionError.new(invalid_motion) if invalid_motion
+        @actions << [sequence, action, block]
+      end
+
+      def start(button, x, y, base_x, base_y)
+        @button = button
+        @processor.start(x, y)
+        @base_x = base_x
+        @base_y = base_y
+        @locus = [[x, y]]
+      end
+
+      def button_release(x, y, width, height)
+        perform_action
+      end
+
+      def button_motion(x, y, width, height)
+        new_x = @base_x + x
+        new_y = @base_y + y
+        @locus << [new_x, new_y]
+        @processor.update_position(new_x, new_y)
+      end
+
+      def draw_last_locus(renderer)
+        if @locus.size >= 2
+          x1, y1 = @locus[-2]
+          x2, y2 = @locus[-1]
+          args = [x1, y1, x2, y2, @line_color, {:line_width => @line_width}]
+          renderer.draw_line(*args)
+        end
+      end
+
+      def draw(renderer)
+        if @back_color.alpha == 1.0 or
+            (@back_color.alpha < 1.0 and renderer.alpha_available?)
+          args = [true, 0, 0, renderer.width, renderer.height]
+          args << @back_color
+          renderer.draw_rectangle(*args)
+        end
+
+        draw_available_marks(renderer, next_available_motions)
+
+        act, = action
+        draw_mark(renderer, act, *@processor.position) if act
+
+        draw_locus(renderer)
+      end
+
+      def draw_locus(renderer)
+        return if @locus.empty?
+        renderer.draw_lines(@locus, @line_color, {:line_width => @line_width})
+      end
+
+      def moved?
+        @locus.size >= 2
+      end
+
+      private
+      def perform_action
+        act, block = action
+        @processor.reset
+        @locus.clear
+        if act
+          act.activate(&block)
+          true
+        else
+          false
+        end
+      end
+
+      def action
+        motions = @processor.motions
+        @actions.each do |sequence, act, block|
+          return [act, block] if sequence == motions and act.sensitive?
+        end
+        nil
+      end
+
+      def available_motions
+        motions = @processor.motions
+        @actions.collect do |sequence, act, block|
+          if sequence == motions and act.sensitive?
+            [sequence.last, act]
+          else
+            nil
+          end
+        end.compact.uniq
+      end
+
+      def next_available_motions
+        motions = @processor.motions
+        @actions.collect do |sequence, act, block|
+          if sequence[0..-2] == motions and act.sensitive?
+            [sequence.last, act]
+          else
+            nil
+          end
+        end.compact.uniq
+      end
+
+      def match?
+        not action.nil?
+      end
+
+      def draw_mark(renderer, act, x=nil, y=nil, radius=nil)
+        x ||= @processor.position[0]
+        y ||= @processor.position[1]
+        radius ||= @processor.threshold / 2.0
+        renderer.draw_circle_by_radius(true, x, y, radius, @current_color)
+        draw_action_image(renderer, act, x, y)
+      end
+
+      def draw_action_image(renderer, act, x, y)
+        icon = nil
+        icon = act.create_icon(Gtk::IconSize::DIALOG) if act
+        if icon
+          pixbuf = icon.render_icon(icon.stock, icon.icon_size, act.name)
+          x -= pixbuf.width / 2.0
+          y -= pixbuf.height / 2.0
+          renderer.draw_pixbuf(pixbuf, x, y)
+        elsif block_given?
+          yield
+        end
+      end
+
+      def draw_available_marks(renderer, infos)
+        infos.each do |motion, act|
+          args = [motion, %w(R), %w(L), %w(UR LR), %w(UL LL)]
+          adjust_x = calc_position_ratio(*args)
+          args = [motion, %w(D), %w(U), %w(LR LL), %w(UR UL)]
+          adjust_y = calc_position_ratio(*args)
+
+          threshold = @processor.threshold
+          x, y = @processor.position
+          center_x = x + threshold * adjust_x
+          center_y = y + threshold * adjust_y
+          draw_action_image(renderer, act, center_x, center_y) do
+            angle = @processor.skew_threshold_angle
+            base_angle = calc_position_angle(motion) - angle
+            args = [false, x, y, threshold, base_angle, angle * 2]
+            args.concat([@next_color, {:line_width => @next_width}])
+            renderer.draw_arc_by_radius(*args)
+          end
+        end
+      end
+
+      def calc_position_ratio(motion, inc, dec, inc_skew, dec_skew)
+        case motion
+        when *inc
+          1
+        when *inc_skew
+          1 / Math.sqrt(2)
+        when *dec
+          -1
+        when *dec_skew
+          -1 / Math.sqrt(2)
+        else
+          0
+        end
+      end
+
+      MOTION_TO_ANGLE = {
+        "R" => 0,
+        "UR" => 45,
+        "U" => 90,
+        "UL" => 135,
+        "L" => 180,
+        "LL" => 225,
+        "D" => 270,
+        "LR" => 315,
+      }
+      def calc_position_angle(motion)
+        MOTION_TO_ANGLE[motion]
+      end
+
+      def make_color(color)
+        color ||= @back_color
+        if color.is_a?(Renderer::Color)
+          color
+        else
+          Renderer::Color.parse(color)
+        end
+      end
+    end
+  end
+end