rabbit 3.0.4 → 4.0.0

data/lib/rabbit/action/basic.rb

@@ -1,304 +0,0 @@
-module Rabbit
-  module Action
-    module_function
-    def act_next(action, group, canvas)
-      canvas.move_to_next_if_can
-    end
-    def act_next_config(config, canvas)
-      config[:label] = N_("Next")
-      config[:stock_id] = Gtk::Stock::GO_FORWARD
-    end
-
-    def act_previous(action, group, canvas)
-      canvas.move_to_previous_if_can
-    end
-    def act_previous_config(config, canvas)
-      config[:label] = N_("Previous")
-      config[:stock_id] = Gtk::Stock::GO_BACK
-    end
-
-    def act_next_slide(action, group, canvas)
-      canvas.move_to_next_slide_if_can
-    end
-    def act_next_slide_config(config, canvas)
-      config[:label] = N_("Next slide")
-      config[:stock_id] = Gtk::Stock::GO_FORWARD
-    end
-
-    def act_previous_slide(action, group, canvas)
-      canvas.move_to_previous_slide_if_can
-    end
-    def act_previous_slide_config(config, canvas)
-      config[:label] = N_("Previous slide")
-      config[:stock_id] = Gtk::Stock::GO_BACK
-    end
-
-    def act_first_slide(action, group, canvas)
-      canvas.move_to_first
-    end
-    def act_first_slide_config(config, canvas)
-      config[:label] = N_("First slide")
-      config[:stock_id] = Gtk::Stock::GOTO_FIRST
-    end
-
-    def act_last_slide(action, group, canvas)
-      canvas.move_to_last
-    end
-    def act_last_slide_config(config, canvas)
-      config[:label] = N_("Last slide")
-      config[:stock_id] = Gtk::Stock::GOTO_LAST
-    end
-
-    def act_jump_to(action, group, canvas)
-      if action.block_given?
-        canvas.move_to_if_can(action.call(action, group, canvas))
-      end
-    end
-    def act_jump_to_config(config, canvas)
-      config[:label] = N_("Jump to")
-      config[:stock_id] = Gtk::Stock::JUMP_TO
-    end
-
-    def update_move_slide_action_status(canvas)
-      canvas.action("Previous").sensitive = canvas.have_previous?
-      canvas.action("Next").sensitive = canvas.have_next?
-      canvas.action("PreviousSlide").sensitive = canvas.have_previous_slide?
-      canvas.action("NextSlide").sensitive = canvas.have_next_slide?
-      canvas.action("FirstSlide").sensitive = !canvas.first_slide?
-      canvas.action("LastSlide").sensitive = !canvas.last_slide?
-    end
-
-    def act_save_as_image(action, group, canvas)
-      canvas.save_as_image
-    end
-    def act_save_as_image_config(config, canvas)
-      config[:label] = N_("Save as image")
-      config[:stock_id] = Gtk::Stock::SAVE
-    end
-
-    def act_print(action, group, canvas)
-      canvas.print
-    end
-    def act_print_config(config, canvas)
-      config[:label] = N_("Print")
-      config[:stock_id] = Gtk::Stock::PRINT
-    end
-
-    def act_iconify(action, group, canvas)
-      canvas.iconify
-    end
-    def act_iconify_config(config, canvas)
-      config[:label] = N_("Iconify")
-      config[:stock_id] = Stock::RABBIT
-    end
-
-    def act_change_theme(action, group, canvas)
-      if action.block_given?
-        entry, block = action.call(action, group, canvas)
-        canvas.apply_theme(entry.name, &block)
-      end
-    end
-    def act_change_theme_config(config, canvas)
-      config[:label] = N_("Change theme")
-    end
-
-    def act_merge_theme(action, group, canvas)
-      if action.block_given?
-        entry, block = action.call(action, group, canvas)
-        canvas.merge_theme(entry.name, &block)
-      end
-    end
-    def act_merge_theme_config(config, canvas)
-      config[:label] = N_("Merge theme")
-    end
-
-    def act_reload_theme(action, group, canvas)
-      block = nil
-      block = action.call(action, group, canvas) if action.block_given?
-      canvas.reload_theme(&block)
-    end
-    def act_reload_theme_config(config, canvas)
-      config[:label] = N_("Reload theme")
-      config[:stock_id] = Gtk::Stock::REFRESH
-    end
-
-    def act_redraw(action, group, canvas)
-      canvas.redraw
-    end
-    def act_redraw_config(config, canvas)
-      config[:label] = N_("Redraw")
-      config[:stock_id] = Gtk::Stock::REFRESH
-    end
-
-    def act_clear_slide(action, group, canvas)
-      canvas.clear_slide
-    end
-    def act_clear_slide_config(config, canvas)
-      config[:label] = N_("Clear slide")
-      config[:stock_id] = Gtk::Stock::CLEAR
-    end
-
-    def update_theme_action_status(canvas)
-      not_applying = !canvas.applying?
-      canvas.action("ReloadTheme").sensitive = not_applying
-      canvas.action("ChangeTheme").sensitive = not_applying
-      canvas.action("MergeTheme").sensitive = not_applying
-      canvas.action("CacheAllSlides").sensitive = not_applying
-      canvas.action("ToggleFullScreen").sensitive = not_applying
-    end
-
-    @@quit_label = N_("_Quit")
-    @@quit_with_confirmation_label = N_("_Quit with confirmation")
-    def quit_action_label(canvas)
-      canvas.processing? ? @@quit_with_confirmation_label : @@quit_label
-    end
-
-    def act_quit(action, group, canvas)
-      if !canvas.processing? or
-          canvas.confirm(_("Now processing... Do you really quit?"))
-        canvas.quit
-      end
-    end
-    def act_quit_config(config, canvas)
-      config[:label] = quit_action_label(canvas)
-      config[:stock_id] = Gtk::Stock::QUIT
-    end
-
-    def update_quit_action_status(canvas)
-      canvas.action("Quit").label = _(quit_action_label(canvas))
-    end
-
-    def act_cache_all_slides(action, group, canvas)
-      canvas.cache_all_slides
-    end
-    def act_cache_all_slides_config(config, canvas)
-      config[:label] = N_("Cache all slides")
-    end
-
-    def act_graffiti(action, group, canvas)
-      update_graffiti_action_status(canvas)
-    end
-    def act_graffiti_config(config, canvas)
-      config[:label] = N_("Graffiti")
-      config[:stock_id] = Gtk::Stock::EDIT
-    end
-
-    def act_clear_graffiti(action, group, canvas)
-      canvas.clear_graffiti
-    end
-    def act_clear_graffiti_config(config, canvas)
-      config[:label] = N_("Clear graffiti")
-      config[:stock_id] = Gtk::Stock::CLEAR
-    end
-
-    def act_undo_graffiti(action, group, canvas)
-      canvas.undo_graffiti
-    end
-    def act_undo_graffiti_config(config, canvas)
-      config[:label] = N_("Undo graffiti")
-      config[:stock_id] = Gtk::Stock::UNDO
-    end
-
-    def act_change_graffiti_color(action, group, canvas)
-      canvas.change_graffiti_color
-    end
-    def act_change_graffiti_color_config(config, canvas)
-      config[:label] = N_("Change graffiti color")
-      config[:stock_id] = Gtk::Stock::SELECT_COLOR
-    end
-
-    def update_graffiti_action_status(canvas)
-      graffiti_available = canvas.graffiti_mode? || canvas.have_graffiti?
-      canvas.action("Graffiti").sensitive = graffiti_available
-      #canvas.action("ClearGraffiti").sensitive = canvas.have_graffiti?
-      #canvas.action("UndoGraffiti").sensitive = canvas.can_undo_graffiti?
-      canvas.action("ClearGraffiti").sensitive = graffiti_available
-      canvas.action("UndoGraffiti").sensitive = graffiti_available
-      canvas.action("ChangeGraffitiColor").sensitive = graffiti_available
-    end
-
-    def act_reset_adjustment(action, group, canvas)
-      canvas.reset_adjustment
-    end
-    def act_reset_adjustment_config(config, canvas)
-      config[:label] = N_("Reset adjustment")
-      config[:stock_id] = Gtk::Stock::CLEAR
-    end
-
-    def act_reset_timer(action, group, canvas)
-      canvas.reset_timer
-    end
-    def act_reset_timer_config(config, canvas)
-      config[:label] = N_("Reset timer")
-      config[:stock_id] = Gtk::Stock::CLEAR
-    end
-
-    def act_expand_hole(action, group, canvas)
-      canvas.expand_hole
-    end
-    def act_expand_hole_config(config, canvas)
-      config[:label] = N_("Expand hole")
-    end
-
-    def act_narrow_hole(action, group, canvas)
-      canvas.narrow_hole
-    end
-    def act_narrow_hole_config(config, canvas)
-      config[:label] = N_("Narrow hole")
-    end
-
-    def act_search_slide_forward(action, group, canvas)
-      canvas.search_slide(true)
-      update_saarch_action_status(canvas)
-    end
-    def act_search_slide_forward_config(config, canvas)
-      config[:label] = N_("Search slide forward")
-    end
-
-    def act_search_slide_backward(action, group, canvas)
-      canvas.search_slide(false)
-      update_saarch_action_status(canvas)
-    end
-    def act_search_slide_backward_config(config, canvas)
-      config[:label] = N_("Search slide backward")
-    end
-
-    def act_search_slide_forward_next(action, group, canvas)
-      canvas.search_slide(true)
-      update_saarch_action_status(canvas)
-    end
-    def act_search_slide_forward_next_config(config, canvas)
-      config[:label] = N_("Search slide forward next")
-    end
-
-    def act_search_slide_backward_next(action, group, canvas)
-      canvas.search_slide(false)
-      update_saarch_action_status(canvas)
-    end
-    def act_search_slide_backward_next_config(config, canvas)
-      config[:label] = N_("Search slide backward next")
-    end
-
-    def act_stop_slide_search(action, group, canvas)
-      canvas.stop_slide_search
-      update_saarch_action_status(canvas)
-    end
-    def act_stop_slide_search_config(config, canvas)
-      config[:label] = N_("Stop slide search")
-    end
-
-    def update_saarch_action_status(canvas)
-      canvas.action("SearchSlideForward").sensitive = !canvas.searching?
-      canvas.action("SearchSlideBackward").sensitive = !canvas.searching?
-      canvas.action("SearchSlideForwardNext").sensitive = canvas.searching?
-      canvas.action("SearchSlideBackwardNext").sensitive = canvas.searching?
-      canvas.action("StopSlideSearch").sensitive = canvas.searching?
-    end
-
-    def act_log_level(action, group, canvas)
-    end
-    def act_log_level_config(config, canvas)
-      config[:label] = N_("Log Level")
-    end
-  end
-end

data/lib/rabbit/action/radio.rb

@@ -1,78 +0,0 @@
-module Rabbit
-  module Action
-    module_function
-    @@radio_blank_values = [
-      [:white, 1],
-      [:black, 2],
-      [:show, 3],
-    ]
-    def act_radio_blank(action, current, group, canvas)
-      case @@radio_blank_values.rassoc(current.value)[0]
-      when :white
-        canvas.toggle_whiteout
-      when :black
-        canvas.toggle_blackout
-      when :show
-        if canvas.whiteouting?
-          canvas.toggle_whiteout
-        elsif canvas.blackouting?
-          canvas.toggle_blackout
-        end
-      else
-        p "????"
-      end
-    end
-
-    def act_radio_blank_whiteout_config(config, canvas)
-      config[:label] = N_("Whiteout")
-      config[:value] = @@radio_blank_values.assoc(:white)[1]
-      config[:default] = canvas.whiteouting?
-    end
-    def act_radio_blank_blackout_config(config, canvas)
-      config[:label] = N_("Blackout")
-      config[:value] = @@radio_blank_values.assoc(:black)[1]
-      config[:default] = canvas.blackouting?
-    end
-    def act_radio_blank_show_config(config, canvas)
-      config[:label] = N_("Show")
-      config[:value] = @@radio_blank_values.assoc(:show)[1]
-      config[:default] = !canvas.whiteouting? && !canvas.blackouting?
-    end
-
-
-    def act_radio_log_level(action, current, group, canvas)
-      canvas.logger.level = current.value
-    end
-
-    def act_radio_log_level_debug_config(config, canvas)
-      config[:label] = N_("Debug")
-      config[:value] = Logger::Severity::DEBUG
-      config[:default] = canvas.logger.level == config[:value]
-    end
-    def act_radio_log_level_info_config(config, canvas)
-      config[:label] = N_("Info")
-      config[:value] = Logger::Severity::INFO
-      config[:default] = canvas.logger.level == config[:value]
-    end
-    def act_radio_log_level_warning_config(config, canvas)
-      config[:label] = N_("Warning")
-      config[:value] = Logger::Severity::WARNING
-      config[:default] = canvas.logger.level == config[:value]
-    end
-    def act_radio_log_level_error_config(config, canvas)
-      config[:label] = N_("Error")
-      config[:value] = Logger::Severity::ERROR
-      config[:default] = canvas.logger.level == config[:value]
-    end
-    def act_radio_log_level_fatal_config(config, canvas)
-      config[:label] = N_("Fatal")
-      config[:value] = Logger::Severity::FATAL
-      config[:default] = canvas.logger.level == config[:value]
-    end
-    def act_radio_log_level_unknown_config(config, canvas)
-      config[:label] = N_("Unknown")
-      config[:value] = Logger::Severity::UNKNOWN
-      config[:default] = canvas.logger.level == config[:value]
-    end
-  end
-end

data/lib/rabbit/action/toggle.rb

@@ -1,82 +0,0 @@
-module Rabbit
-  module Action
-    module_function
-    def act_toggle_whiteout(action, group, canvas)
-      if canvas.whiteouting?
-        canvas.activate("RadioBlankShow")
-      else
-        canvas.activate("RadioBlankWhiteout")
-      end
-    end
-    def act_toggle_whiteout_config(config, canvas)
-      config[:label] = N_("Whiteout")
-    end
-
-    def act_toggle_blackout(action, group, canvas)
-      if canvas.blackouting?
-        canvas.activate("RadioBlankShow")
-      else
-        canvas.activate("RadioBlankBlackout")
-      end
-    end
-    def act_toggle_blackout_config(config, canvas)
-      config[:label] = N_("Blackout")
-    end
-
-    def act_toggle_index_mode(action, group, canvas)
-      canvas.toggle_index_mode
-    end
-    def act_toggle_index_mode_config(config, canvas)
-      config[:label] = N_("Index mode")
-      config[:stock_id] = Gtk::Stock::INDEX
-    end
-
-    def act_toggle_full_screen(action, group, canvas)
-      canvas.toggle_fullscreen
-    end
-    def act_toggle_full_screen_config(config, canvas)
-      config[:label] = N_("Full screen")
-      if Gtk::Stock.const_defined?(:FULLSCREEN)
-        config[:stock_id] = Gtk::Stock::FULLSCREEN
-      else
-        config[:stock_id] = Gtk::Stock::ZOOM_FIT
-      end
-    end
-
-    def act_toggle_graffiti_mode(action, group, canvas)
-      canvas.toggle_graffiti_mode
-    end
-    def act_toggle_graffiti_mode_config(config, canvas)
-      config[:label] = N_("Graffiti mode")
-      config[:stock_id] = Gtk::Stock::EDIT
-    end
-
-    def act_toggle_info_window(action, group, canvas)
-      canvas.toggle_info_window
-    end
-    def act_toggle_info_window_config(config, canvas)
-      config[:label] = N_("Information window")
-    end
-
-    def act_toggle_spotlight(action, group, canvas)
-      canvas.toggle_spotlight
-    end
-    def act_toggle_spotlight_config(config, canvas)
-      config[:label] = N_("Spotlight")
-    end
-
-    def act_toggle_magnifier(action, group, canvas)
-      canvas.toggle_magnifier
-    end
-    def act_toggle_magnifier_config(config, canvas)
-      config[:label] = N_("Magnifier")
-    end
-
-    def act_toggle_terminal(action, group, canvas)
-      canvas.toggle_terminal
-    end
-    def act_toggle_terminal_config(config, canvas)
-      config[:label] = N_("Terminal")
-    end
-  end
-end

data/lib/rabbit/action.rb

@@ -1,140 +0,0 @@
-# Copyright (C) 2005-2024  Sutou Kouhei <kou@cozmixng.org>
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-require "rabbit/gtk"
-
-require 'rabbit/rabbit'
-require 'rabbit/stock'
-require 'rabbit/utils'
-
-module Rabbit
-  module Action
-    extend Utils
-    include GetText
-
-    @@actions = []
-    @@toggle_actions = []
-    @@radio_actions = []
-    @@update_status_methods = []
-    class << self
-      def method_added(name)
-        case name.to_s
-        when /_config$/
-          # ignore
-        when /^act_(radio_.+)$/
-          @@radio_actions << [Utils.to_class_name($1), name]
-        when /^act_(toggle_.+)$/
-          @@toggle_actions << [Utils.to_class_name($1), name]
-        when /^act_(.+)$/
-          @@actions << [Utils.to_class_name($1), name]
-        when /^update_(.+)_status$/
-          @@update_status_methods << name
-        end
-      end
-
-      def action_group(canvas, name="Rabbit")
-        Stock.init(canvas)
-        group = Gtk::ActionGroup.new(name)
-        group.set_translate_func(&method(:_))
-        group.add_actions(to_gtk_actions(@@actions, canvas))
-        actions = to_gtk_actions(@@toggle_actions, canvas, true)
-        group.add_toggle_actions(actions)
-        add_radio_actions(group, @@radio_actions, canvas)
-        group
-      end
-
-      def update_status(canvas)
-        @@update_status_methods.each do |method|
-          __send__(method, canvas)
-        end
-      end
-
-      private
-      def to_gtk_actions(actions, canvas, toggle=false)
-        actions.collect do |name, action|
-          config = {:label => name}
-          config_method = "#{action}_config"
-          __send__(config_method, config, canvas) if respond_to?(config_method)
-          callback = method(action)
-          result = [
-            name,
-            config[:stock_id],
-            config[:label],
-            config[:accelerator],
-            config[:tooltip],
-            Proc.new do |group, act|
-              guard(canvas) do
-                callback.call(act, group, canvas)
-              end
-            end
-          ]
-          result << config[:is_active] if toggle
-          result
-        end
-      end
-
-      def add_radio_actions(group, actions, canvas)
-        actions.each do |name, action|
-          default_value = nil
-          gtk_actions = methods(false).find_all do |method_name|
-            /^#{action}_(?:.+)_config$/ =~ method_name
-          end.collect do |config_method|
-            /^act_(.*)_config$/ =~ config_method
-            action_name = Utils.to_class_name($1)
-            config = {:label => action_name}
-            __send__(config_method, config, canvas)
-            default_value = config[:value] if config[:default]
-            [
-              action_name,
-              config[:stock_id],
-              config[:label],
-              config[:accelerator],
-              config[:tooltip],
-              config[:value],
-            ]
-          end
-
-          callback = method(action)
-          group.add_radio_actions(gtk_actions, default_value) do |act, current|
-            guard(canvas) do
-              callback.call(act, current, group, canvas)
-            end
-          end
-        end
-      end
-
-      def guard(canvas)
-        begin
-          yield
-        rescue Exception
-          canvas.logger.warn($!)
-        end
-      end
-    end
-
-    module_function
-    def update_processing_action_status(canvas)
-      canvas.action("ToggleIndexMode").sensitive = !canvas.processing?
-      canvas.action("CacheAllSlides").sensitive = !canvas.processing?
-      canvas.action("SaveAsImage").sensitive = !canvas.processing?
-      canvas.action("Print").sensitive = !canvas.processing?
-    end
-  end
-end
-
-require "rabbit/action/basic"
-require "rabbit/action/radio"
-require "rabbit/action/toggle"

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

@@ -1,98 +0,0 @@
-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
-