rabbit 0.6.2

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

@@ -0,0 +1,173 @@
+require 'forwardable'
+
+require 'rabbit/renderer/base'
+require 'rabbit/renderer/pixmap'
+require 'rabbit/renderer/display/drawing-area-base'
+
+module Rabbit
+  module Renderer
+    module Display
+      class CommentDrawingArea
+        include DrawingAreaBase
+
+        extend Forwardable
+
+        def_delegators(:@pixmap, :foreground, :background)
+        def_delegators(:@pixmap, :foreground=, :background=)
+        def_delegators(:@pixmap, :background_image, :background_image=)
+
+        def_delegators(:@pixmap, :prepare_renderer, :finish_renderer)
+
+        def_delegators(:@pixmap, :draw_slide, :draw_line, :draw_rectangle)
+        def_delegators(:@pixmap, :draw_arc, :draw_circle, :draw_layout)
+        def_delegators(:@pixmap, :draw_arc_by_radius, :draw_circle_by_radius)
+        def_delegators(:@pixmap, :draw_pixbuf, :draw_polygon)
+        def_delegators(:@pixmap, :draw_rounded_rectangle)
+
+        def_delegators(:@pixmap, :draw_cube, :draw_sphere, :draw_cone)
+        def_delegators(:@pixmap, :draw_torus, :draw_tetrahedron)
+        def_delegators(:@pixmap, :draw_octahedron, :draw_dodecahedron)
+        def_delegators(:@pixmap, :draw_icosahedron, :draw_teapot)
+
+        def_delegators(:@pixmap, :gl_compile, :gl_call_list)
+        def_delegators(:@pixmap, :gl_supported?)
+
+        def_delegators(:@pixmap, :filename, :filename=)
+
+        def_delegators(:@pixmap, :x_dpi, :y_dpi)
+
+        attr_accessor :direction
+
+        def width
+          original_height
+        end
+
+        def height
+          original_width
+        end
+
+        def initialize(canvas)
+          super
+          clear_pixbufs
+          init_pixmap(1, 1)
+          @direction = :right
+        end
+
+        def clear_keys
+        end
+
+        def update_menu
+        end
+
+        def post_apply_theme
+          clear_pixbufs
+          super
+        end
+
+        def toggle_comment_frame
+        end
+
+        def toggle_comment_view
+        end
+
+        def showing_comment_frame?
+          false
+        end
+
+        def showing_comment_view?
+          false
+        end
+
+        def comment_frame_available?
+          false
+        end
+
+        def comment_view_available?
+          false
+        end
+
+        def update_comment(*args, &block)
+        end
+
+        def post_init_gui
+        end
+
+        def post_toggle_index_mode
+          clear_pixbufs
+          super
+        end
+
+        private
+        def add_widget_to_window(window)
+          window.add(@area)
+        end
+
+        def remove_widget_from_window(window)
+          window.remove(@area)
+        end
+
+        def attach_menu(window)
+          # do nothing
+        end
+
+        def detach_menu(window)
+          # do nothing
+        end
+
+        def attach_key(window)
+          # do nothing
+        end
+
+        def detach_key(window)
+          # do nothing
+        end
+
+        def init_drawing_area
+          super
+          @area.can_focus = false
+        end
+
+        def init_color
+          super
+          @fg_gc = Gdk::GC.new(@drawable)
+        end
+
+        def init_pixmap(w=width, h=height)
+          @pixmap = Renderer::Pixmap.new(@canvas, w, h)
+          @pixmap.setup_event(self)
+        end
+
+        def clear_pixbuf(slide=nil)
+          @pixbufs.delete(@pixmap[slide || @canvas.current_slide])
+        end
+
+        def clear_pixbufs
+          @pixbufs = {}
+        end
+
+        def slide_to_pixbuf(slide)
+          pixbuf = @pixmap.to_pixbuf(slide)
+          pixbuf.rotate(Gdk::Pixbuf::ROTATE_CLOCKWISE)
+        end
+
+        def draw_current_slide
+          slide = @canvas.current_slide
+          if slide
+            unless @pixbufs.has_key?(slide)
+              @pixmap.width = width
+              @pixmap.height = height
+              @pixbufs[slide] = slide_to_pixbuf(slide)
+            end
+            @drawable.draw_pixbuf(@fg_gc, @pixbufs[slide],
+                                  0, 0, 0, 0, -1, -1,
+                                  Gdk::RGB::DITHER_NORMAL, 0, 0)
+          end
+        end
+
+        def init_renderer(drawable)
+          init_pixmap(*drawable.size)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,194 @@
+require 'rabbit/comment-canvas'
+require "rabbit/comment/log"
+
+module Rabbit
+  module Renderer
+    module Display
+      module Comment
+        def initialize(*args, &block)
+          super
+          @comment_initialized = false
+          init_comment_log
+        end
+
+        def showing_comment_frame?
+          @comment_frame and @comment_frame.visible?
+        end
+
+        def showing_comment_view?
+          @comment_log.showing?
+        end
+
+        def comment_frame_available?
+          true
+        end
+
+        def comment_view_available?
+          true
+        end
+
+        def toggle_comment_frame
+          ensure_comment
+          if showing_comment_frame?
+            @comment_frame.hide
+          else
+            adjust_comment_frame
+            @comment_frame.show
+          end
+          update_menu
+        end
+
+        def toggle_comment_view
+          ensure_comment
+          if showing_comment_view?
+            @comment_log.hide
+            @comment_view_frame.hide
+          else
+            adjust_comment_view
+            @comment_log.show
+            @comment_view_frame.show
+            @comment_view_canvas.parse(@canvas.comment_source)
+            @comment_view_canvas.move_to_last
+          end
+          adjust_comment_frame
+        end
+
+        def update_comment(source, &block)
+          ensure_comment
+          error_occurred = parse_comment(source, &block)
+          unless error_occurred
+            @comment_canvas.move_to_last
+            @comment_log.reset(@comment_canvas)
+            if @comment_view_frame.visible?
+              @comment_view_frame.parse(source)
+              @comment_view_canvas.move_to_last
+            end
+          end
+        end
+
+        def post_init_gui
+          super
+          @comment_log.hide
+          @comment_view_frame.hide if @comment_view_frame
+        end
+
+        private
+        def add_widget_to_window(window)
+          super
+          @vbox.pack_end(@comment_log.widget, false, false, 0)
+          init_comment_view_canvas
+          init_comment_view_frame
+          @hbox.pack_start(@comment_view_frame.window, false, false, 0)
+        end
+
+        def parse_comment(source)
+          error_occurred = false
+          @comment_canvas.parse(source) do |error|
+            error_occurred = true
+            if block_given?
+              yield(error)
+            else
+              @comment_canvas.logger.warn(error)
+            end
+          end
+          error_occurred
+        end
+
+        def ensure_comment
+          unless @comment_initialized
+            init_comment
+            @comment_initialized = true
+          end
+        end
+
+        def init_comment
+          init_comment_canvas
+          init_comment_frame
+          @comment_canvas.parse(@canvas.comment_source)
+        end
+
+        def init_comment_frame
+          @comment_frame = Frame.new(@comment_canvas.logger, @comment_canvas)
+          w, h = suggested_comment_frame_size
+          @comment_frame.init_gui(w, h, false, Gtk::Window::POPUP)
+          @comment_frame.hide
+        end
+
+        def init_comment_canvas
+          @comment_canvas = Canvas.new(@canvas.logger, DrawingArea)
+          @comment_canvas.use_gl = @canvas.use_gl?
+        end
+
+        def init_comment_view_frame
+          args = [@comment_view_canvas.logger, @comment_view_canvas]
+          @comment_view_frame = EmbedFrame.new(*args)
+          @comment_view_frame.init_gui(-1, -1, false)
+          @comment_view_frame.hide
+        end
+
+        def init_comment_view_canvas
+          @comment_view_canvas = CommentCanvas.new(@canvas.logger,
+                                                   CommentDrawingArea)
+          @comment_view_canvas.saved_image_base_name =
+            @canvas.saved_image_base_name
+          @comment_view_canvas.filename = @canvas.filename
+          @comment_view_canvas.slides_per_page = @canvas.slides_per_page
+          @comment_view_canvas.use_gl = @canvas.use_gl?
+        end
+
+        def init_comment_log
+          @comment_log = Rabbit::Comment::Log.new
+        end
+
+        def adjust_comment_frame(x=nil, y=nil, w=nil, h=nil)
+          if @comment_initialized
+            w, h = suggested_comment_frame_size(w, h)
+            @comment_frame.window.set_size_request(w, h)
+            Utils.move_to_bottom_left(@window, @comment_frame.window)
+          end
+        end
+
+        def adjust_comment_view(x=nil, y=nil, w=nil, h=nil)
+          ww, wh = suggested_comment_log_window_size(w, h)
+          @comment_log.widget.set_size_request(ww, wh)
+          begin
+            header_height = @comment_log.header_height
+          rescue TypeError
+            header_height = nil
+          end
+          if header_height
+            text_size = (wh - header_height) * 0.5
+          else
+            text_size = wh * 0.4
+          end
+          @comment_log.font_size = text_size * Pango::SCALE
+
+          fw, fh = suggested_comment_view_frame_size(w, h)
+          @comment_view_frame.set_size_request(fw, fh)
+        end
+
+        def suggested_comment_frame_size(w=nil, h=nil)
+          w ||= @canvas.width
+          h ||= @canvas.height
+          [w / 10, h / 10]
+        end
+
+        def suggested_comment_log_window_size(w=nil, h=nil)
+          h ||= @canvas.height
+          [-1, h / 10]
+        end
+
+        def suggested_comment_view_frame_size(w=nil, h=nil)
+          w ||= @canvas.width
+          [w / 10, -1]
+        end
+
+        def configured(x, y, w, h)
+          super
+          adjust_comment_frame(x, y, w, h)
+          adjust_comment_view(x, y, w, h)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require "rabbit/cursor-manager"
+
+module Rabbit
+  module Renderer
+    module Display
+      module Cursor
+        def initialize(*args, &block)
+          super
+          init_cursor
+        end
+
+        private
+        def init_cursor
+          @cursor_manager = CursorManager.new
+        end
+
+        def keep_cursor(name)
+          @cursor_manager.keep(name)
+        end
+
+        def restore_cursor(name)
+          @cursor_manager.restore(@drawable, name)
+        end
+
+        def update_cursor(cursor_type, update_current_cursor=false)
+          @cursor_manager.current = cursor_type if update_current_cursor
+          cursor_type = :pencil if @graffiti_mode
+          @cursor_manager.update(@drawable, cursor_type)
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,395 @@
+require "rabbit/renderer/display/drawing-area-primitive"
+require 'rabbit/renderer/display/menu'
+require "rabbit/renderer/display/progress"
+require "rabbit/renderer/display/mask"
+require "rabbit/renderer/display/search"
+require "rabbit/renderer/display/gesture"
+require "rabbit/renderer/display/graffiti"
+require "rabbit/renderer/display/menu"
+require "rabbit/renderer/display/button-handler"
+require "rabbit/renderer/display/key-handler"
+require "rabbit/renderer/display/info"
+require "rabbit/renderer/display/spotlight"
+require "rabbit/renderer/display/magnifier"
+
+module Rabbit
+  module Renderer
+    module Display
+      module DrawingAreaBase
+        include DrawingAreaPrimitive
+
+        include Menu
+        include Graffiti
+        include Mask
+        include Progress
+        include Search
+        include Gesture
+        include KeyHandler
+        include ButtonHandler
+        include Info
+        include Spotlight
+        include Magnifier
+
+        def initialize(canvas)
+          @caching = nil
+          @need_reload_theme = false
+          super
+        end
+
+        def post_apply_theme
+          if @need_reload_theme
+            @need_reload_theme = false
+            reload_theme
+          else
+            super
+            update_menu
+          end
+        end
+
+        def post_move(old_index, index)
+          update_title
+          reset_adjustment
+          clear_graffiti
+          # toggle_graffiti_mode if @graffiti_mode
+          super
+        end
+
+        def post_fullscreen
+          super
+          update_menu
+        end
+
+        def post_unfullscreen
+          super
+          update_menu
+        end
+
+        def post_iconify
+          super
+          update_menu
+        end
+
+        def pre_parse
+          super
+          update_menu
+        end
+
+        def post_parse
+          super
+          clear_button_handler
+          update_title
+          update_menu
+          if @need_reload_theme
+            @need_reload_theme = false
+            reload_theme
+          end
+        end
+
+        def index_mode_on
+          super
+        end
+
+        def index_mode_off
+          super
+        end
+
+        def pre_toggle_index_mode
+          super
+          Utils.process_pending_events
+        end
+
+        def post_toggle_index_mode
+          @canvas.activate("ClearGraffiti")
+          update_menu
+          update_title
+          super
+        end
+
+        def pre_print(slide_size)
+          start_progress(slide_size)
+        end
+
+        def printing(i)
+          update_progress(i)
+          continue = !@canvas.quitted?
+          continue
+        end
+
+        def post_print(canceled)
+          end_progress
+        end
+
+        def pre_to_pixbuf(slide_size)
+          super
+          start_progress(slide_size)
+          @pixbufing_size = [width, height]
+        end
+
+        def to_pixbufing(i)
+          update_progress(i)
+          continue = @pixbufing_size == [width, height] &&
+            !@canvas.quitted? && !@canvas.applying?
+          super or continue
+        end
+
+        def post_to_pixbuf(canceled)
+          super
+          end_progress
+        end
+
+        def cache_all_slides
+          pre_cache_all_slides(@canvas.slide_size)
+          canceled = false
+          @canvas.slides.each_with_index do |slide, i|
+            @canvas.change_current_index(i) do
+              compile_slide(slide)
+            end
+            unless caching_all_slides(i)
+              canceled = true
+              break
+            end
+          end
+          post_cache_all_slides(canceled)
+        end
+
+        def pre_cache_all_slides(slide_size)
+          @caching = true
+          @caching_size = [width, height]
+          start_progress(slide_size)
+        end
+
+        def caching_all_slides(i)
+          update_progress(i)
+          continue = @caching_size == [width, height] &&
+            !@canvas.quitted? && !@canvas.applying?
+          continue
+        end
+
+        def post_cache_all_slides(canceled)
+          end_progress
+          @caching = false
+          return if @canvas.quitted?
+          if canceled
+            reload_theme
+          else
+            @area.queue_draw
+          end
+        end
+
+        def confirm(message)
+          confirm_dialog(message) == Gtk::MessageDialog::RESPONSE_OK
+        end
+
+        def reload_theme(&callback)
+          if @canvas.applying?
+            @need_reload_theme = true
+          else
+            super
+          end
+        end
+
+        def reload_source(&callback)
+          if @canvas.need_reload_source?
+            callback ||= Utils.process_pending_events_proc
+            super(callback)
+          end
+        end
+
+        def attach_to(window)
+          super
+
+          init_menu
+          init_gesture_actions
+          add_widget_to_window(@window)
+          widget.show
+          attach_menu(@window)
+          attach_key(@window)
+        end
+
+        def detach
+          detach_key(@window)
+          detach_menu(@window)
+          widget.hide
+          unless @window.destroyed?
+            remove_widget_from_window(@window)
+            @window.signal_handler_disconnect(@configure_signal_id)
+          end
+
+          super
+        end
+
+        def toggle_whiteout
+          super
+          @area.queue_draw
+        end
+
+        def toggle_blackout
+          super
+          @area.queue_draw
+        end
+
+        def reset_adjustment
+          super
+          @area.queue_draw
+        end
+
+        def post_init_gui
+        end
+
+        private
+        def add_widget_to_window(window)
+          @hbox = Gtk::HBox.new
+          @vbox = Gtk::VBox.new
+          @vbox.pack_start(@area, true, true, 0)
+          @hbox.pack_end(@vbox, true, true, 0)
+          window.add(@hbox)
+          @hbox.show
+          @vbox.show
+        end
+
+        def remove_widget_from_window(window)
+          window.remove(@hbox)
+          @hbox = @vbox = nil
+        end
+
+        def init_drawing_area
+          super
+          event_mask = Gdk::Event::BUTTON_PRESS_MASK
+          event_mask |= Gdk::Event::BUTTON_RELEASE_MASK
+          event_mask |= Gdk::Event::BUTTON1_MOTION_MASK
+          event_mask |= Gdk::Event::BUTTON2_MOTION_MASK
+          event_mask |= Gdk::Event::BUTTON3_MOTION_MASK
+          @area.add_events(event_mask)
+          set_key_press_event(@area)
+          set_button_event(@area)
+          set_motion_notify_event
+          set_scroll_event
+        end
+
+        def mapped(widget)
+          super
+          @white = Gdk::GC.new(@drawable)
+          @white.set_rgb_fg_color(Color.parse("white").to_gdk_color)
+          @black = Gdk::GC.new(@drawable)
+          @black.set_rgb_fg_color(Color.parse("black").to_gdk_color)
+        end
+
+        def set_motion_notify_event
+          @area.signal_connect("motion_notify_event") do |widget, event|
+            call_hook_procs(@motion_notify_hook_procs, event)
+          end
+        end
+
+        def exposed(widget, event)
+          reload_source unless @caching
+
+          if whiteouting?
+            @drawable.draw_rectangle(@white, true, 0, 0,
+                                     original_width, original_height)
+          elsif blackouting?
+            @drawable.draw_rectangle(@black, true, 0, 0,
+                                     original_width, original_height)
+          else
+            super
+            draw_graffiti
+            draw_gesture
+            draw_spotlight
+          end
+          true
+        end
+
+        def draw_slide(slide, simulation, &block)
+          super do |*args|
+            block.call(*args)
+            magnify {block.call(*args)} unless simulation
+          end
+        end
+
+        def draw_current_slide_pixbuf(pixbuf)
+          width, height = pixbuf.width, pixbuf.height
+          x = @adjustment_x * width
+          y = @adjustment_y * height
+          @drawable.draw_pixbuf(@foreground, pixbuf,
+                                x, y, 0, 0, width, height,
+                                Gdk::RGB::DITHER_NORMAL, 0, 0)
+          if @adjustment_x != 0 or @adjustment_y != 0
+            draw_next_slide
+          end
+        end
+
+        def draw_next_slide
+          @canvas.change_current_index(@canvas.current_index + 1) do
+            draw_current_slide do |pixbuf|
+              draw_next_slide_pixbuf(pixbuf)
+            end
+          end
+        end
+
+        def draw_next_slide_pixbuf(pixbuf)
+          width, height = pixbuf.size
+          adjustment_width = @adjustment_x * width
+          adjustment_height = @adjustment_y * height
+          src_x = src_y = dest_x = dest_y = 0
+          src_width = width
+          src_height = height
+
+          if adjustment_width > 0
+            dest_x = width - adjustment_width
+            src_width = adjustment_width
+          elsif adjustment_width < 0
+            src_x = width + adjustment_width
+            src_width = -adjustment_width
+          end
+
+          if adjustment_height > 0
+            dest_y = height - adjustment_height
+            src_height = adjustment_height
+          elsif adjustment_height < 0
+            src_y = height + adjustment_height
+            src_height = -adjustment_height
+          end
+
+          @drawable.draw_pixbuf(@foreground, pixbuf, src_x, src_y,
+                                dest_x, dest_y, src_width, src_height,
+                                Gdk::RGB::DITHER_NORMAL, 0, 0)
+        end
+
+        def configured_after(widget, event)
+          @mask = nil
+          set_hole
+          super unless @caching
+          false
+        end
+
+        def set_scroll_event
+          @area.signal_connect("scroll_event") do |widget, event|
+            handled = call_hook_procs(@scroll_hook_procs, event)
+            unless handled
+              handled = true
+              case event.direction
+              when Gdk::EventScroll::Direction::UP
+                @canvas.activate("PreviousSlide")
+              when Gdk::EventScroll::Direction::DOWN
+                @canvas.activate("NextSlide")
+              else
+                handled = false
+              end
+            end
+            handled
+          end
+        end
+
+        def confirm_dialog(message)
+          flags = Gtk::Dialog::MODAL | Gtk::Dialog::DESTROY_WITH_PARENT
+          dialog_type = Gtk::MessageDialog::INFO
+          buttons = Gtk::MessageDialog::BUTTONS_OK_CANCEL
+          dialog = Gtk::MessageDialog.new(nil, flags, dialog_type,
+                                          buttons, message)
+          result = dialog.run
+          dialog.destroy
+          result
+        end
+      end
+    end
+  end
+end