rabbit 0.6.2

data/lib/rabbit/logger.rb

@@ -0,0 +1,14 @@
+require "rabbit/utils"
+
+module Rabbit
+  module Logger
+    extend Utils
+
+    dir = ::File.join("rabbit", "logger")
+    require_files_under_directory_in_load_path(dir)
+
+    def self.types
+      collect_classes_under_module(self)
+    end
+  end
+end

data/lib/rabbit/logger/base.rb

@@ -0,0 +1,129 @@
+require "rabbit/gettext"
+
+module Rabbit
+  module Logger
+
+    module Severity
+      extend GetText
+
+      DEBUG = 0
+      INFO = 1
+      WARNING = 2
+      ERROR = 3
+      FATAL = 4
+      UNKNOWN = 5
+
+      MARK_TABLE = {
+        DEBUG => N_("DEBUG"),
+        INFO => N_("INFO"),
+        WARNING => N_("WARNING"),
+        ERROR => N_("ERROR"),
+        FATAL => N_("FATAL"),
+        UNKNOWN => N_("UNKNOWN"),
+      }
+
+      class << self
+        def names
+          MARK_TABLE.sort_by {|key, _| key}.collect {|_, value| value.downcase}
+        end
+
+        def name(level)
+          MARK_TABLE[level].downcase
+        end
+
+        def level(name)
+          MARK_TABLE.find do |key, value|
+            value.downcase == name.downcase
+          end[0]
+        end
+      end
+    end
+
+    module Base
+      include Severity
+      include GetText
+
+      attr_accessor :level, :webrick_mode
+      def initialize(level=INFO, prog_name=nil)
+        @level = level
+        @prog_name = prog_name
+        @webrick_mode = false
+      end
+      
+      def debug?; @level <= DEBUG; end
+      def info?; @level <= INFO; end
+      def warning?; @level <= WARNING; end
+      def error?; @level <= ERROR; end
+      def fatal?; @level <= FATAL; end
+      def unknown?; @level <= UNKNOWN; end
+    
+      def debug(message_or_error=nil, &block)
+        log(DEBUG, message_or_error, &block)
+      end
+      
+      def info(message_or_error=nil, &block)
+        log(INFO, message_or_error, &block)
+      end
+      
+      def warn(message_or_error=nil, &block)
+        log(WARNING, message_or_error, &block)
+      end
+
+      def error(message_or_error=nil, &block)
+        log(ERROR, message_or_error, &block)
+      end
+
+      def fatal(message_or_error=nil, &block)
+        log(FATAL, message_or_error, &block)
+      end
+      
+      def unknown(message_or_error=nil, &block)
+        log(UNKNOWN, message_or_error, &block)
+      end
+
+      def <<(message_or_error)
+        info(message_or_error)
+      end
+      
+      def log(severity, message_or_error, prog_name=nil, &block)
+        severity ||= UNKNOWN
+        prog_name ||= @prog_name
+        if need_log?(severity)
+          if message_or_error.nil? and block_given?
+            message_or_error = yield
+          end
+          if message_or_error
+            do_log(severity, prog_name, make_message(message_or_error))
+          end
+        end
+      end
+      alias add log
+
+      private
+      def format_severity(severity)
+        "[#{_(Severity::MARK_TABLE[severity])}]"
+      end
+
+      def format_datetime(datetime)
+        datetime.strftime("%Y-%m-%dT%H:%M:%S.") << "%06d " % datetime.usec
+      end
+
+      def make_message(message_or_error)
+        if message_or_error.is_a?(Exception)
+          "#{message_or_error.class}: #{message_or_error.message}\n" +
+            %Q[#{message_or_error.backtrace.join("\n")}]
+        else
+          message_or_error
+        end
+      end
+
+      def need_log?(severity)
+        if @webrick_mode
+          severity <= WEBrick::Log::DEBUG - @level
+        else
+          severity >= @level
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/logger/gui.rb

@@ -0,0 +1,172 @@
+require "gtk2"
+
+require "rabbit/keys"
+require "rabbit/logger/base"
+
+module Rabbit
+  module Logger
+
+    class GUI
+      include Base
+
+      attr_accessor :start_gui_main_loop_automatically
+      def initialize(level=nil, width=450, height=400)
+        Gtk.init
+        super(*[level].compact)
+        @width = width
+        @height = height
+        @start_gui_main_loop_automatically = false
+        init_dialog
+      end
+
+      def clear_buffer
+        @buffer.text = ""
+      end
+
+      def quit
+        @dialog.destroy
+      end
+
+      private
+      def do_log(severity, prog_name, message)
+        # ::STDERR.puts(format_severity(severity))
+        # ::STDERR.puts(GLib.filename_from_utf8(message))
+        @current_severity = severity
+        init_dialog if @dialog.destroyed?
+        @dialog.show_all
+        log_severity(severity)
+        log_prog_name(prog_name)
+        log_message(message)
+        if @start_gui_main_loop_automatically and Gtk.main_level.zero?
+          Thread.new{Gtk.main}
+        end
+      end
+
+      def log_severity(severity)
+        append("[")
+        name = severity_name(severity)
+        append(name, name)
+        append("]\n")
+      end
+
+      def log_prog_name(prog_name)
+        if prog_name
+          append("#{prog_name}: ", "prog_name")
+        end
+      end
+      
+      def log_message(message)
+        unless GLib.utf8_validate(message)
+          message = GLib.filename_to_utf8(message)
+        end
+        append(message, "message")
+        append("\n")
+      end
+
+      def append(text, *tags)
+        iter = @buffer.get_iter_at_offset(-1)
+        @buffer.insert_with_tags(iter, text, *tags)
+      end
+
+      def title
+        _("Rabbit Error Dialog")
+      end
+      
+      def init_dialog(width=@width, height=@height)
+        flags = 0
+        buttons = [
+          [Gtk::Stock::CLEAR, Gtk::Dialog::RESPONSE_CANCEL],
+          [Gtk::Stock::CLOSE, Gtk::Dialog::RESPONSE_CLOSE],
+        ]
+        @dialog = Gtk::Dialog.new(title, nil, flags, *buttons)
+        @dialog.vbox.add(init_buffer)
+        @dialog.set_default_size(width, height)
+        set_dialog_delete
+        set_dialog_response
+        set_dialog_expose_event
+        set_dialog_accel_group
+      end
+
+      def set_dialog_delete
+        @dialog.signal_connect("destroy") do |widget, event|
+          exit if @current_severity >= FATAL
+          true
+        end
+      end
+      
+      def set_dialog_response
+        @dialog.signal_connect("response") do |widget, event|
+          case event
+          when Gtk::Dialog::RESPONSE_CANCEL
+            clear_buffer
+          when Gtk::Dialog::RESPONSE_CLOSE
+            quit
+          end
+          true
+        end
+      end
+
+      def set_dialog_expose_event
+        @dialog.signal_connect("expose_event") do |widget, event|
+          @dialog.title = title
+          false
+        end
+      end
+      
+      def set_dialog_accel_group
+        accel_group = Gtk::AccelGroup.new
+        mod = Gdk::Window::ModifierType.new
+        flags = Gtk::AccelFlags::VISIBLE
+        Keys::QUIT_KEYS.each do |val|
+          accel_group.connect(val, mod, flags) do
+            @dialog.signal_emit("response", Gtk::Dialog::RESPONSE_CLOSE)
+            true
+          end
+        end
+        @dialog.add_accel_group(accel_group)
+      end
+
+      def init_buffer
+        textview = Gtk::TextView.new
+        textview.set_editable(false)
+        textview.set_wrap_mode(Gtk::TextTag::WrapMode::WORD)
+        @buffer = textview.buffer
+        create_tags
+        scrolled_window = Gtk::ScrolledWindow.new
+        scrolled_window.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC)
+        scrolled_window.add(textview)
+        scrolled_window
+      end
+
+      def create_tags
+        @buffer.create_tag("DEBUG",
+                           "weight" => Pango::FontDescription::WEIGHT_BOLD,
+                           "foreground" => "blue")
+        @buffer.create_tag("INFO", "foreground" => "blue")
+        @buffer.create_tag("WARN", "foreground" => "red")
+        @buffer.create_tag("ERROR",
+                           "weight" => Pango::FontDescription::WEIGHT_BOLD,
+                           "foreground" => "red")
+        @buffer.create_tag("FATAL",
+                           "foreground" => "yellow",
+                           "background" => "black")
+        @buffer.create_tag("UNKNOWN",
+                           "weight" => Pango::FontDescription::WEIGHT_BOLD,
+                           "foreground" => "yellow",
+                           "background" => "black")
+        @buffer.create_tag("ANY",
+                           "weight" => Pango::FontDescription::WEIGHT_BOLD)
+        @buffer.create_tag("prog_name",
+                           "weight" => Pango::FontDescription::WEIGHT_BOLD,
+                           "foreground" => "blue",
+                           "left_margin" => 10)
+        @buffer.create_tag("message",
+                           "weight" => Pango::FontDescription::WEIGHT_BOLD,
+                           "left_margin" => 10,
+                           "right_margin" => 10)
+      end
+      
+    end
+    
+  end
+end

data/lib/rabbit/logger/stderr.rb

@@ -0,0 +1,28 @@
+require 'glib2'
+
+require "rabbit/logger/base"
+
+module Rabbit
+  module Logger
+
+    class STDERR
+      include Base
+
+      private
+      def do_log(severity, prog_name, message)
+        begin
+          message = GLib.locale_from_utf8(message)
+        rescue GLib::ConvertError
+          format = _("can't convert to current locale from UTF-8: %s")
+          ::STDERR.puts(format % message)
+        end
+        ::STDERR.puts(format_severity(severity))
+        ::STDERR.print("[#{prog_name}]: ") if prog_name
+        ::STDERR.puts(message)
+        exit if severity >= FATAL
+      end
+      
+    end
+    
+  end
+end

data/lib/rabbit/menu.rb

@@ -0,0 +1,287 @@
+require "erb"
+require "stringio"
+
+require "gtk2"
+
+require "rabbit/gettext"
+require "rabbit/utils"
+require "rabbit/theme/searcher"
+require "rabbit/image"
+require "rabbit/action"
+
+module Rabbit
+  class Menu
+    include GetText
+    include ERB::Util
+
+    @@icon = nil
+
+    def initialize(actions)
+      @merge = Gtk::UIManager.new
+      @merge.insert_action_group(actions, 0)
+      @jump_to_actions = nil
+      @jump_to_merge_id = nil
+      @theme_actions = nil
+      @theme_merge_id = nil
+      update_ui
+    end
+
+    def attach(window)
+      window.add_accel_group(accel_group)
+    end
+
+    def detach(window)
+      window.remove_accel_group(accel_group)
+    end
+
+    def update_menu(canvas)
+      update_jump_to_menu(canvas)
+      update_theme_menu(canvas)
+      Action.update_move_slide_action_status(canvas)
+      Action.update_graffiti_action_status(canvas)
+      Action.update_theme_action_status(canvas)
+      Action.update_quit_action_status(canvas)
+      @merge.ensure_update
+      show_tearoff
+    end
+
+    def popup(button, time)
+      @menu.popup(nil, nil, button, time)
+    end
+
+    private
+    def accel_group
+      # @merge.accel_group
+      @accel_group = @merge.accel_group # <- workaround for Ruby/GLib <= 0.18.1
+    end
+
+    def make_jump_to_action(jump_to_action, title, i)
+      name = "JumpTo#{i}"
+      label = "#{i}: #{escape_label(Utils.unescape_title(title))}"
+      tooltip = _("Jump to the %dth slide") % i
+      action = Gtk::Action.new(name, label, tooltip, nil)
+      action.signal_connect("activate") do
+        jump_to_action.activate {i}
+      end
+      action
+    end
+
+    def escape_label(label)
+      label.gsub(/_/, '__')
+    end
+
+    def update_jump_to_menu(canvas)
+      @merge.remove_ui(@jump_to_merge_id) if @jump_to_merge_id
+      @merge.remove_action_group(@jump_to_actions) if @jump_to_actions
+
+      @jump_to_merge_id = @merge.new_merge_id
+      @jump_to_actions = Gtk::ActionGroup.new("JumpToActions")
+      @jump_to_actions_keeper = [] # Workaround for > Ruby/GTK2 0.16
+      @merge.insert_action_group(@jump_to_actions, 0)
+      jump_to_path = "/popup/JumpTo"
+      jump_to_action = canvas.action("JumpTo")
+      return unless jump_to_action
+      canvas.slides.each_with_index do |slide, i|
+        action = make_jump_to_action(jump_to_action, slide.title, i)
+        @jump_to_actions.add_action(action)
+        @jump_to_actions_keeper << action # Workaround for > Ruby/GTK2 0.16
+        @merge.add_ui(@jump_to_merge_id, jump_to_path, action.name,
+                      action.name, Gtk::UIManager::AUTO, false)
+      end
+    end
+    
+    def update_ui
+      @merge_ui = @merge.add_ui(ui_xml)
+      @menu = @merge.get_widget("/popup")
+      tearoff = Gtk::TearoffMenuItem.new
+      tearoff.show
+      @menu.prepend(tearoff)
+    end
+
+    def update_theme_menu(canvas)
+      @merge.remove_ui(@theme_merge_id) if @theme_merge_id
+      @merge.remove_action_group(@theme_actions) if @theme_actions
+      
+      @theme_merge_id = @merge.new_merge_id
+      @theme_actions = Gtk::ActionGroup.new("ThemeActions")
+      @merge.insert_action_group(@theme_actions, 0)
+
+      themes = Theme::Searcher.collect_theme
+      
+      categories = themes.collect do |entry|
+        entry.category
+      end.uniq.sort_by {|cat| _(cat)}
+
+      change = "/popup/ChangeTheme"
+      merge = "/popup/MergeTheme"
+
+      categories.each do |category|
+        theme_menu_add_category("Change", change, category)
+        theme_menu_add_category("Merge", merge, category)
+      end
+
+      themes.each do |entry|
+        theme_menu_add_theme("Change", change, entry, canvas)
+        theme_menu_add_theme("Merge", merge, entry, canvas)
+      end
+    end
+
+    def theme_menu_add_category(prefix, path, category)
+      name = "#{prefix}ThemeCategory#{category}"
+      label = _(category)
+      action = Gtk::Action.new(name, label, nil, nil)
+      @theme_actions.add_action(action)
+      @merge.add_ui(@theme_merge_id, path, category, name,
+                    Gtk::UIManager::MENU, false)
+    end
+
+    def theme_menu_add_theme(prefix, path, entry, canvas)
+      path = "#{path}/#{entry.category}"
+      name = "#{prefix}ThemeEntry#{entry.name}"
+      label = _(entry.title)
+      action = Gtk::Action.new(name, label, nil, nil)
+      action.signal_connect("activate") do
+        canvas.activate("#{prefix}Theme") do
+          [entry, Utils.process_pending_events_proc]
+        end
+      end
+      @theme_actions.add_action(action)
+      @merge.add_ui(@theme_merge_id, path, entry.name, name,
+                    Gtk::UIManager::AUTO, false)
+    end
+
+    def show_tearoff(sub_menus=@menu.children)
+      sub_menus.each do |child|
+        if child.respond_to?(:submenu) and child.submenu
+          tearoff, *child_sub_menus = child.submenu.children
+          tearoff.show
+          show_tearoff(child_sub_menus)
+        end
+      end
+    end
+
+    def ui_xml
+      format_xml(ui_axml)
+    end
+
+    def format_xml(axml)
+      output = StringIO.new
+      @indent = "  "
+      _format_xml(axml, output, 0)
+      output.rewind
+      output.read
+    end
+
+    def _format_xml(axml, output, indent)
+      case axml
+      when Array
+        tag, *others = axml
+        output.print("#{@indent * indent}<#{tag}")
+        if others.first.is_a?(Hash)
+          attrs, *others = others
+          attrs.each do |key, value|
+            output.print(" #{h(key)}=\"#{h(value)}\"") if value
+          end
+        end
+        if others.empty?
+          output.print("/>\n")
+        else
+          output.print(">\n")
+          others.each do |other|
+            _format_xml(other, output, indent + 1)
+          end
+          output.print("#{@indent * indent}</#{tag}>\n")
+        end
+      when String
+        output.print(h(axml))
+      else
+        raise "!?!?!?: #{axml.inspect}"
+      end
+    end
+
+    def ui_axml
+      [:ui,
+        [:popup,
+          *items_to_axml(items)
+        ]
+      ]
+    end
+
+    def items_to_axml(items)
+      items.collect do |key, name, *others|
+        params = {:name => name, :action => name}
+        case key
+        when :separator
+          [:separator]
+        when :item
+          [:menuitem, params]
+        when :menu
+          [:menu, params, *items_to_axml(others)]
+        end
+      end
+    end
+    
+    def items
+      [
+        [:item, "ToggleIndexMode"],
+        [:separator],
+        [:item, "ToggleGraffitiMode"],
+        [:menu, "Graffiti",
+          [:item, "ClearGraffiti"],
+          [:item, "UndoGraffiti"],
+          [:item, "ChangeGraffitiColor"],
+        ],
+        [:separator],
+        [:item, "ToggleFullScreen"],
+        [:separator],
+        [:item, "ToggleInfoWindow"],
+        [:separator],
+        [:item, "RadioBlankWhiteout"],
+        [:item, "RadioBlankBlackout"],
+        [:item, "RadioBlankShow"],
+#         [:separator],
+#         [:item, "ToggleCommentFrame"],
+#         [:item, "ToggleCommentView"],
+        [:separator],
+        [:item, "ToggleSpotlight"],
+        [:item, "ToggleMagnifier"],
+        [:separator],
+        [:menu, "JumpTo"],
+        [:separator],
+        [:item, "Previous"],
+        [:item, "Next"],
+        [:item, "PreviousSlide"],
+        [:item, "NextSlide"],
+        [:item, "FirstSlide"],
+        [:item, "LastSlide"],
+        [:separator],
+        [:item, "Iconify"],
+        [:separator],
+        [:item, "Redraw"],
+        [:item, "ClearSlide"],
+        [:item, "ReloadTheme"],
+        [:menu, "ChangeTheme"],
+        [:menu, "MergeTheme"],
+        [:separator],
+        [:item, "CacheAllSlides"],
+        [:separator],
+        [:item, "SaveAsImage"],
+        [:item, "Print"],
+        [:separator],
+        [:item, "ResetTimer"],
+        [:item, "ResetAdjustment"],
+        [:separator],
+        [:menu, "LogLevel",
+          [:item, "RadioLogLevelDebug"],
+          [:item, "RadioLogLevelInfo"],
+          [:item, "RadioLogLevelWarning"],
+          [:item, "RadioLogLevelError"],
+          [:item, "RadioLogLevelFatal"],
+          [:item, "RadioLogLevelUnknown"],
+        ],
+        [:separator],
+        [:item, "Quit"],
+      ]
+    end
+  end
+end