rabbit 0.6.2

data/lib/rabbit/comment-canvas.rb

@@ -0,0 +1,21 @@
+require 'rabbit/canvas'
+
+module Rabbit
+  class CommentCanvas < Canvas
+    def quit
+      toggle_comment_view
+    end
+
+    def saved_image_base_name
+      super + "_comment"
+    end
+
+    def filename=(new_filename)
+      if new_filename.nil?
+        super(new_filename)
+      else
+        super(new_filename + "_comment")
+      end
+    end
+  end
+end

data/lib/rabbit/comment/log.rb

@@ -0,0 +1,74 @@
+require 'gtk2'
+
+module Rabbit
+  module Comment
+    class Log
+      COMMENT_COLUMN = 0
+
+      def initialize
+        init_window
+      end
+
+      def widget
+        @window
+      end
+
+      def show
+        @window.show_all
+      end
+
+      def hide
+        @window.hide
+      end
+
+      def showing?
+        @window.visible?
+      end
+
+      def reset(canvas)
+        @model.clear
+        canvas.slides[1..-1].each do |slide|
+          iter = @model.prepend
+          iter.set_value(COMMENT_COLUMN, slide.headline.text)
+        end
+      end
+
+      def font_size=(new_size)
+        @renderer_comment.size = new_size
+      end
+
+      def header_height
+        _, _, _, height = @column_comment.cell_size
+        height
+      end
+
+      private
+      def init_model
+        @model = Gtk::ListStore.new(String)
+      end
+
+      def init_view
+        init_model
+        @view = Gtk::TreeView.new(@model)
+        @view.can_focus = false
+        @view.rules_hint = true
+        @renderer_comment = Gtk::CellRendererText.new
+        args = [
+          _("comment"),
+          @renderer_comment,
+          {"text" => COMMENT_COLUMN}
+        ]
+        @column_comment = Gtk::TreeViewColumn.new(*args)
+        @view.append_column(@column_comment)
+      end
+
+      def init_window
+        init_view
+        @window = Gtk::ScrolledWindow.new
+        @window.set_policy(Gtk::POLICY_AUTOMATIC,
+                           Gtk::POLICY_AUTOMATIC)
+        @window.add(@view)
+      end
+    end
+  end
+end

data/lib/rabbit/console.rb

@@ -0,0 +1,133 @@
+require 'English'
+
+require "optparse"
+require "ostruct"
+
+require "rabbit/rabbit"
+require "rabbit/logger"
+
+require "rabbit/console/roff"
+
+Thread.abort_on_exception = true
+
+include Rabbit::GetText
+
+module Rabbit
+  module Console
+    @@locale_dir_option_name = "--locale-dir"
+
+    module_function
+    def parse!(args, logger=nil)
+      bindtextdomain
+      logger ||= Logger::STDERR.new
+      options = OpenStruct.new
+      options.logger = logger
+      options.default_logger = logger
+
+      process_locale_options(args)
+
+      opts = OptionParser.new(banner) do |opts|
+        yield(opts, options)
+        setup_common_options(opts, options)
+      end
+
+      begin
+        opts.parse!(args)
+      rescue
+        logger.fatal($!.message)
+      end
+
+      [options, options.logger]
+    end
+
+    def banner
+      _("Usage: %s [options]") % File.basename($0, '.*')
+    end
+
+    def process_locale_options(args)
+      args.each_with_index do |arg, i|
+        if arg == @@locale_dir_option_name
+          bindtextdomain(args[i + 1])
+        elsif /#{@@locale_dir_option_name}=/ =~ arg
+          bindtextdomain($POSTMATCH)
+        end
+      end
+    end
+
+    def setup_common_options(opts, options)
+      opts.separator ""
+      opts.separator _("Common options")
+
+      setup_locale_options(opts, options)
+      setup_logger_options(opts, options)
+      setup_common_options_on_tail(opts, options)
+    end
+    
+    def setup_locale_options(opts, options)
+      opts.on("--locale-dir=DIR",
+              _("Specify locale dir as [DIR]."),
+              _("(auto)")) do |d|
+        bindtextdomain(d)
+      end
+
+      opts.separator ""
+    end
+
+    def setup_logger_options(opts, options)
+      logger_type_names = Rabbit::Logger.types.collect do |x|
+        get_last_name(x).downcase
+      end
+
+      opts.on("--logger-type=TYPE",
+              logger_type_names,
+              _("Specify logger type as [TYPE]."),
+              _("Select from [%s].") % logger_type_names.join(', '),
+              "(#{get_last_name(options.logger.class)})") do |logger_type|
+        logger_class = Rabbit::Logger.types.find do |t|
+          get_last_name(t).downcase == logger_type.downcase
+        end
+        if logger_class.nil?
+          options.logger = options.default_logger
+          # logger.error("Unknown logger type: #{t}")
+        else
+          options.logger = logger_class.new
+        end
+      end
+
+      level_names = Logger::Severity.names
+      opts.on("--log-level=LEVEL",
+              level_names,
+              _("Specify log level as [LEVEL]."),
+              _("Select from [%s].") % level_names.join(', '),
+              "(#{Logger::Severity.name(options.logger.level)})") do |name|
+        options.logger.level = Logger::Severity.level(name)
+      end
+
+      opts.separator ""
+    end
+
+    def setup_common_options_on_tail(opts, options)
+      opts.on_tail("--help", _("Show this message.")) do
+        output_info_and_exit(options, opts.to_s)
+      end
+
+      opts.on_tail("--version", _("Show version.")) do
+        output_info_and_exit(options, "#{VERSION}\n")
+      end
+    end
+
+    def output_info_and_exit(options, message)
+      if options.logger.is_a?(Logger::STDERR) and
+          options.default_logger == options.logger
+        print(GLib.locale_from_utf8(message))
+      else
+        options.logger.info(message)
+      end
+      exit
+    end
+
+    def get_last_name(klass)
+      klass.name.split("::").last
+    end
+  end
+end

data/lib/rabbit/console/roff.rb

@@ -0,0 +1,84 @@
+require "optparse"
+
+class OptionParser
+  class Category
+    def initialize(str)
+      @name = str
+    end
+
+    def summarize(*args, &block)
+      yield('')
+      yield(@name)
+    end
+
+    def summarize_as_roff(&block)
+      yield(".SH #{::OptionParser.roff_escape(@name)}")
+    end
+  end
+
+  class Switch
+    def summarize_as_roff(&block)
+      var = nil
+      opt_str = [@short, @long].flatten.collect {|s|
+                  "\\fB#{::OptionParser.roff_escape(s)}\\fR"
+                }.join(', ')
+      opt_str << arg.sub(/\A([=\s\[]*)(.+?)([\s\]]*)\z/) {
+        var = $2
+        "#{$1}\\fI#{$2}\\fR#{$3}"
+      } if arg
+      yield('.TP')
+      yield(opt_str)
+      desc.each do |d|
+        d_str = ::OptionParser.roff_escape(d)
+        d_str.gsub!(var) { "\\fI#{var}\\fR" } if var
+        yield(d_str)
+      end
+    end
+  end
+
+  class List
+    def summarize_as_roff(&block)
+      list.each do |opt|
+        if opt.respond_to?(:summarize_as_roff)
+          opt.summarize_as_roff(&block)
+        end
+        # FIXME: and otherwise process separators and banners...
+      end
+    end
+  end
+
+  # TODO: decide whether we show this option in the option summary.
+  Officious['roff'] = proc do |parser|
+    Switch::NoArgument.new do
+      puts parser.roff
+      exit
+    end
+  end
+
+  # TODO: make this option user-visible after implementing all.
+  Officious['man'] = proc do |parser|
+    Switch::NoArgument.new do
+      IO.popen('man -l -', 'w') do |io|
+        io.puts parser.roff
+      end
+      exit
+    end
+  end
+
+  def roff
+    to = [%[.TH #{self.class.roff_escape(program_name.upcase)} "1"]]
+    visit(:summarize_as_roff) do |l|
+      to << l + $/
+    end
+    to
+  end
+
+  def category(str)
+    top.append(Category.new(str), nil, nil)
+  end
+
+  def self.roff_escape(str)
+    str.gsub(/[-\\]/, '\\\\\\&').gsub(/^[.']/, '\\&') # '
+    # TODO: taken over from rd2man-lib.rb, necessary to be confirmed
+  end
+end

data/lib/rabbit/cursor-manager.rb

@@ -0,0 +1,62 @@
+require 'gtk2'
+
+require 'rabbit/rabbit'
+
+module Rabbit
+  class CursorManager
+    @@blank_cursor = nil
+
+    attr_accessor :current
+    def initialize
+      @stocks = {}
+      @current = nil
+      @blank_cursor = blank_cursor
+      @pencil_cursor = Gdk::Cursor.new(Gdk::Cursor::PENCIL)
+      @hand_cursor = Gdk::Cursor.new(Gdk::Cursor::HAND1)
+    end
+
+    def keep(name)
+      @stocks[name] ||= []
+      @stocks[name].push(@current)
+    end
+
+    def restore(drawable, name)
+      if name.nil?
+	type = @current
+      else
+	type = @stocks[name].pop
+      end
+      drawable.cursor = type_to_cursor(type)
+    end
+
+    def update(drawable, type)
+      drawable.cursor = type_to_cursor(type)
+    end
+
+    private
+    def type_to_cursor(type)
+      if type.nil?
+	nil
+      else
+	name = "@#{type}_cursor"
+	unless instance_variables.include?(name)
+	  raise UnknownCursorTypeError.new(type)
+	end
+	instance_variable_get(name)
+      end
+    end
+
+    def blank_cursor
+      if @@blank_cursor.nil?
+	source = Gdk::Pixmap.new(nil, 1, 1, 1)
+	mask = Gdk::Pixmap.new(nil, 1, 1, 1)
+	gc = Gdk::GC.new(source)
+	fg = gc.foreground
+	bg = gc.background
+	@@blank_cursor = Gdk::Cursor.new(source, mask, fg, bg, 1, 1)
+      end
+      @@blank_cursor
+    end
+  end
+end
+

data/lib/rabbit/default-config.rb

@@ -0,0 +1,16 @@
+require 'rbconfig'
+
+module Rabbit
+  module Config
+    IMAGE_PATH = [
+      ::Config::CONFIG["datadir"],
+      File.join(".", "data"),
+    ]
+    if Object.const_defined?(:Gem)
+      rabbit_gem_spec = Gem.loaded_specs["rabbit"]
+      if rabbit_gem_spec and rabbit_gem_spec.loaded?
+        IMAGE_PATH.unshift(File.join(rabbit_gem_spec.full_gem_path, "data"))
+      end
+    end
+  end
+end

data/lib/rabbit/dependency-canvas.rb

@@ -0,0 +1,14 @@
+require 'rabbit/canvas'
+
+module Rabbit
+  class DependencyCanvas < Canvas
+    extend Forwardable
+
+    def_delegators(:@parent, :theme_name, :allotted_time, :rest_time)
+
+    def initialize(parent, *rest, &block)
+      @parent = parent
+      super(*rest, &block)
+    end
+  end
+end

data/lib/rabbit/div/comment-i.erb

@@ -0,0 +1,7 @@
+<p>
+<%= form("comment", context) %>
+<input type="text" class="comment" value="" name="<%= comment_param_name %>" />
+<input type="submit" name="submit-comment" value="GO!" />
+</form>
+</p>
+<%= to_log_html(context) %>

data/lib/rabbit/div/comment.erb

@@ -0,0 +1,45 @@
+<div class="comment">
+<p>
+<script type="text/javascript">
+function updateLog() {
+  new Ajax.Updater({success: 'log'},
+                   <%= action(context).dump %>,
+                   {
+                     method: 'get',
+                     parameters: <%= ajax_param("comment") %>
+                   })
+}
+
+function appendComment() {
+  Form.disable(<%= comment_form_name.dump %>);
+  new Ajax.Updater({success: 'log'},
+                   <%= action(context).dump %>,
+                   {
+                     method: 'get',
+                     parameters:
+                       <%= ajax_param("comment", comment_param_name) %>,
+                     onSuccess: function() {
+                       $(<%= comment_param_name.dump %>).value = "";
+                       Form.enable(<%= comment_form_name.dump %>);
+		     },
+                     onFailure: function() {
+                       Form.enable(<%= comment_form_name.dump %>);
+		     }
+                   });
+}
+</script>
+<%= form2({"id" => comment_form_name,
+           "onsubmit" => "appendComment(); return false;"},
+          "comment", context) %>
+<input type="text" class="comment" value=""
+       id="<%= comment_param_name %>" name="<%= comment_param_name %>" />
+<input type="submit" name="submit-comment" value="GO!" />
+</form>
+</p>
+<p class="log" id="log">
+</p>
+<script type="text/javascript">
+updateLog();
+new PeriodicalExecuter(updateLog, 10);
+</script>
+</div>