rabbit 0.6.2

data/lib/rabbit/renderer/print/layout.rb

@@ -0,0 +1,123 @@
+require "forwardable"
+
+require "rabbit/rabbit"
+
+module Rabbit
+  module Renderer
+    module Print
+      class LayoutBase
+        extend Forwardable
+
+        class << self
+          def make_layout(renderer)
+            map = LAYOUT_MAPPING.find do |key, value|
+              key === renderer.slides_per_page
+            end
+            if map.nil?
+              raise InvalidPages.new(renderer.slides_per_page)
+            else
+              map[1].new(renderer)
+            end
+          end
+        end
+
+        def_delegators(:@renderer, :slides_per_page)
+        def_delegators(:@renderer, :current_index)
+        def_delegators(:@renderer, :page_width, :page_height)
+
+        def initialize(renderer)
+          @renderer = renderer
+          @margin_left = renderer.margin_left
+          @margin_right = renderer.margin_right
+          @margin_top = renderer.margin_top
+          @margin_bottom = renderer.margin_bottom
+        end
+      end
+      
+      class Layout2 < LayoutBase
+
+        def initialize(renderer)
+          super
+          @margin_left ||= 50
+          @margin_right ||= 50
+          @margin_top ||= 30
+          @margin_bottom ||= 30
+        end
+        
+        def slide_width
+          page_width - @margin_left - @margin_right
+        end
+
+        def slide_height
+          (page_height / 2) - @margin_top - @margin_bottom
+        end
+        
+        def normalize_x(x)
+          x + @margin_left
+        end
+
+        def normalize_y(y)
+          base = @margin_bottom
+          if below?
+            base += @margin_top + @margin_bottom + slide_height
+          end
+          y + base
+        end
+
+        private
+        def below?
+          (current_index % 2) == 1
+        end
+      end
+      
+      class LayoutMore < LayoutBase
+        def initialize(renderer)
+          super
+          @margin_left ||= 10
+          @margin_right ||= 10
+          @margin_top ||= 10
+          @margin_bottom ||= 10
+        end
+        
+        def slide_width
+          (page_width / 2) - @margin_left - @margin_right
+        end
+
+        def slide_height
+          base = page_height / (slides_per_page / 2.0).ceil
+          base - @margin_top - @margin_bottom
+        end
+        
+        def normalize_x(x)
+          base = @margin_left
+          unless left?
+            base += @margin_left + @margin_right + slide_width
+          end
+          x + base
+        end
+
+        def normalize_y(y)
+          nth_col = (normalized_current_index / 2.0).truncate
+          base = @margin_top * (nth_col + 1)
+          base += @margin_bottom * nth_col
+          base += slide_height * nth_col
+          y + base
+        end
+
+        private
+        def left?
+          (normalized_current_index % 2).zero?
+        end
+
+        def normalized_current_index
+          current_index % slides_per_page
+        end
+      end
+
+      LAYOUT_MAPPING = [
+        [2, Layout2],
+        [3..(1.0/0), LayoutMore],
+      ]
+    end
+  end
+end

data/lib/rabbit/renderer/print/multiple.rb

@@ -0,0 +1,205 @@
+require "forwardable"
+
+require 'rabbit/renderer/kernel'
+require "rabbit/renderer/print/base"
+require "rabbit/renderer/print/layout"
+
+module Rabbit
+  module Renderer
+    module Print
+      class Multiple
+        include Base
+        include Kernel
+        extend Forwardable
+      
+        def_delegators(:@canvas, :current_index)
+        
+        def_delegators(:@print, :filename, :filename=)
+        def_delegators(:@print, :foreground=, :background=)
+        def_delegators(:@print, :background_image=)
+        
+        def_delegators(:@print, :page_width, :page_width=)
+        def_delegators(:@print, :page_height, :page_height=)
+        def_delegators(:@print, :width, :height)
+        
+        def_delegators(:@print, :pre_print, :post_print, :post_apply_theme)
+        def_delegators(:@print, :post_move, :post_move_in_slide, :post_iconify)
+        def_delegators(:@print, :post_fullscreen, :post_unfullscreen)
+        def_delegators(:@print, :pre_parse, :post_parse)
+        def_delegators(:@print, :post_toggle_index_mode)
+        def_delegators(:@print, :index_mode_on, :index_mode_off)
+
+        def_delegators(:@print, :make_color, :make_layout)
+        def_delegators(:@print, :create_pango_context)
+        
+        def_delegators(:@print, :clear_theme)
+
+        def_delegators(:@print, :rsvg_available?, :poppler_available?)
+        def_delegators(:@print, :rsvg_available?, :poppler_available?)
+
+        def initialize(canvas)
+          @print = Print.new(canvas)
+          super
+        end
+        
+        def width
+          @slide_width ||= @layout.slide_width
+        end
+
+        def height
+          @slide_height ||= @layout.slide_height
+        end
+
+        def page_margin_left=(margin)
+          super
+          @print.page_margin_left = margin
+        end
+
+        def page_margin_right=(margin)
+          super
+          @print.page_margin_right = margin
+        end
+        
+        def page_margin_top=(margin)
+          super
+          @print.page_margin_top = margin
+        end
+        
+        def page_margin_bottom=(margin)
+          super
+          @print.page_margin_bottom = margin
+        end
+
+        def margin_left=(margin)
+          super
+          @print.margin_left = margin
+        end
+
+        def margin_right=(margin)
+          super
+          @print.margin_right = margin
+        end
+        
+        def margin_top=(margin)
+          super
+          @print.margin_top = margin
+        end
+        
+        def margin_bottom=(margin)
+          super
+          @print.margin_bottom = margin
+        end
+
+        
+        def draw_slide(slide, simulation)
+          @print.show_page = need_show_page?
+          @print.internal_draw_slide(slide, simulation) do
+            if simulation
+              yield
+            else
+              @print.save_context do
+                x, y = normalize(0, 0)
+                @print.internal_clip_slide(x, y, width, height)
+                @print.internal_draw_background(x, y, width, height)
+                yield
+                draw_rectangle(false, 0, 0, width, height, @black)
+              end
+            end
+          end
+        end
+
+        def slides_per_page=(slides)
+          super
+          update_layout
+        end
+
+        def draw_line(x1, y1, x2, y2, color=nil, params={})
+          x1, y1 = normalize(x1, y1)
+          x2, y2 = normalize(x2, y2)
+          @print.draw_line(x1, y1, x2, y2, color, params)
+        end
+
+        def draw_rectangle(filled, x, y, w, h, color=nil, params={})
+          x, y = normalize(x, y)
+          @print.draw_rectangle(filled, x, y, w, h, color, params)
+        end
+
+        def draw_rounded_rectangle(filled, x, y, w, h, radius, color=nil,
+                                   params={})
+          x, y = normalize(x, y)
+          @print.draw_rounded_rectangle(filled, x, y, w, h, radius,
+                                        color, params)
+        end
+
+        def draw_arc(filled, x, y, w, h, a1, a2, color=nil, params={})
+          x, y = normalize(x, y)
+          @print.draw_arc(filled, x, y, w, h, a1, a2, color, params)
+        end
+
+        def draw_arc_by_radius(filled, x, y, r, a1, a2, color=nil, params={})
+          x, y = normalize(x, y)
+          @print.draw_arc_by_radius(filled, x, y, r, a1, a2, color, params)
+        end
+
+        def draw_layout(layout, x, y, color=nil, params={})
+          x, y = normalize(x, y)
+          @print.draw_layout(layout, x, y, color, params)
+        end
+
+        def draw_pixbuf(pixbuf, x, y, params={})
+          x, y = normalize(x, y)
+          @print.draw_pixbuf(pixbuf, x, y, params)
+        end
+
+        def draw_rsvg_handle(handle, x, y, params={})
+          x, y = normalize(x, y)
+          @print.draw_rsvg_handle(handle, x, y, params)
+        end
+
+        def draw_poppler_page(handle, x, y, params={})
+          x, y = normalize(x, y)
+          @print.draw_poppler_page(handle, x, y, params)
+        end
+
+        private
+        def init_paper
+          @print.paper_width = A4_WIDTH
+          @print.paper_height = A4_HEIGHT
+        end
+
+        def init_color
+          @white = make_color("white")
+          @black = make_color("black")
+        end
+
+        def update_layout
+          if @slides_per_page
+            @layout = LayoutBase.make_layout(self)
+          else
+            @layout = nil
+          end
+          @slide_width = nil
+          @slide_height = nil
+        end
+
+        def normalize_x(x)
+          @layout.normalize_x(x)
+        end
+        alias nx normalize_x
+
+        def normalize_y(y)
+          @layout.normalize_y(y)
+        end
+        alias ny normalize_y
+
+        def normalize(x, y)
+          [nx(x), ny(y)]
+        end
+
+        def need_show_page?
+          @canvas.last_slide? or ((current_index + 1) % @slides_per_page).zero?
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/search-window.rb

@@ -0,0 +1,99 @@
+require 'gtk2'
+
+require 'rabbit/searcher'
+
+module Rabbit
+  class SearchWindow
+
+    attr_accessor :window, :direction, :entry
+    def initialize(canvas)
+      @canvas = canvas
+      @searcher = Searcher.new(canvas)
+      init_window
+    end
+
+    def show
+      send_focus_change(true)
+      @window.show
+    end
+
+    def hide
+      send_focus_change(false)
+      @window.hide
+    end
+
+    def forward=(forward)
+      @direction.active = forward
+    end
+
+    def forward?
+      @direction.active?
+    end
+
+    def empty?
+      /\A\s*\z/ =~ @entry.text
+    end
+
+    def regexp
+      @searcher.regexp(@entry.text)
+    end
+
+    private
+    def init_window
+      @window = Gtk::Window.new(Gtk::Window::POPUP)
+      @window.modal = true
+      init_frame
+      init_box
+      init_entry
+      init_direction
+    end
+
+    def init_frame
+      @frame = Gtk::Frame.new
+      @frame.shadow_type = Gtk::ShadowType::ETCHED_IN
+      @frame.show
+      @window.add(@frame)
+    end
+
+    def init_box
+      @box = Gtk::HBox.new
+      @box.border_width = 3
+      @box.show
+      @frame.add(@box)
+    end
+
+    def init_entry
+      @entry = Gtk::Entry.new
+      @entry.show
+      @box.add(@entry)
+    end
+
+    def init_direction
+      @direction = Gtk::ToggleButton.new
+      @arrow = Gtk::Arrow.new(Gtk::Arrow::LEFT, Gtk::SHADOW_NONE)
+      @arrow.show
+      @direction.add(@arrow)
+      @direction.can_focus = false
+      @direction.show
+      @box.add(@direction)
+      @direction.signal_connect("toggled") do |button|
+        if forward?
+          type = Gtk::Arrow::RIGHT
+        else
+          type = Gtk::Arrow::LEFT
+        end
+        @arrow.set(type, Gtk::SHADOW_NONE)
+      end
+      @direction.active = true
+    end
+
+    def send_focus_change(focus_in)
+      @entry.has_focus = focus_in
+      event = Gdk::EventFocus.new(Gdk::EventFocus::FOCUS_CHANGE)
+      event.window = @entry.window
+      event.in = focus_in
+      @entry.event(event)
+      @entry.notify("has-focus")
+    end
+  end
+end

data/lib/rabbit/searcher.rb

@@ -0,0 +1,106 @@
+require 'rabbit/utils'
+
+Rabbit::Converter.keep_kcode("EUC-JP") do
+  begin
+    require 'migemo'
+  rescue LoadError
+  end
+end
+
+module Rabbit
+  class Searcher
+    @@migemo_static_dict = nil
+    @@migemo_static_dict_cache = nil
+
+    def initialize(canvas)
+      @canvas = canvas
+    end
+
+    def regexp(text)
+      unless text == @text
+        @text = text
+        @regexp = nil
+      end
+      @regexp ||= internal_regexp
+    end
+
+    private
+    def internal_regexp
+      if migemo_available?
+        migemo_regexp
+      else
+        begin
+          /#{@text}/iu
+        rescue RegexpError
+          /#{Regexp.escape(@text)}/iu
+        end
+      end
+    end
+
+    def migemo_regexp
+      text = Converter.to_eucjp_from_utf8(@text)
+      segments = migemo_split_text(text)
+      if segments.size <= 1
+        regexp_str = migemo_generate_regexp_str(text, false)
+      else
+        regexp_str1 = migemo_generate_regexp_str(text, true)
+        regexp_str2 = segments.collect do |pattern|
+          migemo_generate_regexp_str(pattern, true)
+        end.join
+        regexp_str = [regexp_str1, regexp_str2].join("|")
+      end
+      /#{Converter.to_utf8_from_eucjp(regexp_str)}/iu
+    end
+
+    def migemo_generate_regexp_str(pattern, with_paren)
+      Converter.keep_kcode("EUC-JP") do
+        migemo = Migemo.new(@@migemo_static_dict, pattern)
+        migemo.dict_cache = @@migemo_static_dict_cache
+        migemo.with_paren = with_paren
+        migemo.regex
+      end
+    end
+
+    def migemo_split_text(text)
+      text.scan(/[A-Z]?[^A-Z]+|[A-Z]+/e)
+    end
+
+    def migemo_available?
+      defined?(::Migemo) and have_migemo_static_dict?
+    end
+
+    def have_migemo_static_dict?
+      if @@migemo_static_dict.nil?
+        dict, dict_cache = search_migemo_static_dict
+        @@migemo_static_dict, @@migemo_static_dict_cache = dict, dict_cache
+      end
+      not @@migemo_static_dict.nil?
+    end
+
+    def search_migemo_static_dict
+      @canvas.migemo_dictionary_search_path.each do |target|
+        if File.directory?(target)
+          [
+           File.join(target, @canvas.migemo_dictionary_name),
+           File.join(target, "migemo", @canvas.migemo_dictionary_name),
+          ].each do |guess|
+            return make_migemo_dict(guess) if File.readable?(guess)
+          end
+        elsif File.readable?(target)
+          return make_migemo_dict(target)
+        end
+      end
+      nil
+    end
+
+    def make_migemo_dict(path)
+      dict = MigemoStaticDict.new(path)
+      dict_cache = nil
+      dict_cache_path = "#{path}.cache"
+      if File.readable?(dict_cache_path)
+        dict_cache = MigemoDictCache.new(dict_cache_path)
+      end
+      [dict, dict_cache]
+    end
+  end
+end