rabbit 0.6.2

data/lib/rabbit/element/text.rb

@@ -0,0 +1,82 @@
+require 'rabbit/element/text-element'
+require 'rabbit/element/text-container-element'
+require 'rabbit/element/block-element'
+
+module Rabbit
+  module Element
+    class Text
+      include TextElement
+    end
+
+    class TextContainer
+      include TextContainerElement
+    end
+
+    class PreformattedBlock
+      include TextContainerElement
+      include BlockHorizontalCentering
+
+      def to_html(generator)
+        "<pre>#{super}</pre>"
+      end
+    end
+
+    class PreformattedText
+      include TextContainerElement
+    end
+
+    class Keyword
+      include TextContainerElement
+    end
+
+    class Comment
+      include TextContainerElement
+    end
+
+    class Emphasis
+      include TextContainerElement
+    end
+
+    class Code
+      include TextContainerElement
+    end
+
+    class Variable
+      include TextContainerElement
+    end
+
+    class Keyboard
+      include TextContainerElement
+    end
+
+    class Index
+      include TextContainerElement
+    end
+
+    class Note
+      include TextContainerElement
+    end
+
+    class Verbatim
+      include TextContainerElement
+    end
+
+    class DeletedText
+      include TextContainerElement
+    end
+
+    class ReferText
+      include TextContainerElement
+
+      attr_accessor :to
+    end
+
+    class Subscript
+      include TextContainerElement
+    end
+
+    class Superscript
+      include TextContainerElement
+    end
+  end
+end

data/lib/rabbit/element/title-slide.rb

@@ -0,0 +1,190 @@
+require 'rabbit/element/slide-element'
+require 'rabbit/element/text-container-element'
+require 'rabbit/element/description-list'
+
+module Rabbit
+  module Element
+    class TitleSlide
+      include SlideElement
+
+      def <<(element)
+        return unless element.is_a?(DescriptionList)
+        element.each do |item|
+          name = item.term.collect{|x| x.text}.join("")
+          name = normalize_name(name)
+          klass_name = to_class_name(name)
+          if Element.const_defined?(klass_name)
+            meta = Element.const_get(klass_name).new
+            item.content.each do |elem|
+              elem.each do |e|
+                meta << e
+              end
+            end
+            super(meta)
+          else
+            content = ""
+            item.content.each do |x|
+              content << x.text
+            end
+            self[name] = content.strip
+          end
+        end
+      end
+
+      def theme
+        self["theme"]
+      end
+
+      def allotted_time
+        time = self["allotted-time"]
+        time = parse_time(time) if time
+        time
+      end
+
+      def to_html(generator)
+        "<div class=\"title-slide\">\n#{super}\n</div>"
+      end
+
+      def title
+        sub_title = find {|element| element.is_a?(Subtitle)}
+        sub_title = sub_title.text if sub_title
+        [super, sub_title].compact.join(" - ")
+      end
+
+      private
+      def normalize_name(name)
+        name.gsub(/_/, "-").strip
+      end
+
+      def parse_time(str)
+        if /\A\s*\z/m =~ str
+          nil
+        else
+          if /\A\s*(\d*\.?\d*)\s*(h|m|s)?\s*\z/i =~ str
+            time = $1.to_f
+            unit = $2
+            if unit
+              case unit.downcase
+              when "m"
+                time *= 60
+              when "h"
+                time *= 3600
+              end
+            end
+            time.to_i
+          else
+            nil
+          end
+        end
+      end
+    end
+
+    class Title
+      include TextContainerElement
+
+      def to_rd
+        "= #{text}"
+      end
+
+      def to_html(generator)
+        "<h1>#{super}</h1>"
+      end
+    end
+
+    class Subtitle
+      include TextContainerElement
+
+      def to_rd
+        ": subtitle\n   #{text}"
+      end
+
+      def to_html(generator)
+        "<h2>#{super}</h2>"
+      end
+    end
+
+    class Author
+      include TextContainerElement
+
+      def to_rd
+        ": author\n   #{text}"
+      end
+
+      def to_html(generator)
+        "<address>#{super}</address>"
+      end
+    end
+
+    class ContentSource
+      include TextContainerElement
+
+      def to_rd
+        ": content-source\n   #{text}"
+      end
+
+      def to_html(generator)
+        "<p class='content-source'>#{super}</p>"
+      end
+    end
+
+    class Institution
+      include TextContainerElement
+
+      def to_rd
+        ": institution\n   #{text}"
+      end
+
+      def to_html(generator)
+        "<p class='institution'>#{super}</p>"
+      end
+    end
+
+    class Date
+      include TextContainerElement
+
+      def to_rd
+        ": date\n   #{text}"
+      end
+
+      def to_html(generator)
+        "<p class='date'>#{super}</p>"
+      end
+    end
+
+    class Place
+      include TextContainerElement
+
+      def to_rd
+        ": place\n   #{text}"
+      end
+
+      def to_html(generator)
+        "<p class='place'>#{super}</p>"
+      end
+    end
+
+    class When
+      include TextContainerElement
+
+      def to_rd
+        ": when\n   #{text}"
+      end
+
+      def to_html(generator)
+        "<p class='when'>#{super}</p>"
+      end
+    end
+
+    class Where
+      include TextContainerElement
+
+      def to_rd
+        ": where\n   #{text}"
+      end
+
+      def to_html(generator)
+        "<p class='where'>#{super}</p>"
+      end
+    end
+  end
+end

data/lib/rabbit/formatter.rb

@@ -0,0 +1,143 @@
+require "erb"
+require "rabbit/renderer/color"
+
+module Rabbit
+  module Format
+
+    extend Utils
+    
+    module Formatter
+      include ERB::Util
+
+      def text_formatter?
+        false
+      end
+      
+      def html_formatter?
+        false
+      end
+      
+      def tagged_text(text, name, attrs)
+        attrs = attrs.collect do |key, value|
+          %Q[ #{h(key)}="#{h(value)}"]
+        end.join("")
+        "<#{name}#{attrs}>#{text}</#{name}>"
+      end
+    end
+
+    module SpanTextFormatter
+      include Formatter
+
+      PANGO2CSS = {
+        "font_family" => Proc.new do |name, value|
+          ["font-family", "'#{value}'"]
+        end,
+        "foreground" => "color",
+        "size" => Proc.new do |name, value|
+          ["font-size", "#{(value / Pango::SCALE) * 2}px"]
+        end,
+        "style" => "font-style",
+        "weight" => "font-weight",
+      }
+
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+      
+      def text_formatter?
+        true
+      end
+      
+      def html_formatter?
+        true
+      end
+      
+      def format(text)
+        tagged_text(text, "span", normalize_attribute(name, @value))
+      end
+
+      def html_format(text)
+        css_name, css_value = pango2css(name, @value)
+        tagged_text(text, "span", {'style' => "#{css_name}: #{css_value};"})
+      end
+
+      private
+      def normalize_attribute(name, value)
+        {name => value}
+      end
+      
+      def pango2css(name, value)
+        css_name = PANGO2CSS[name]
+        if css_name.respond_to?(:call)
+          css_name.call(name, value)
+        else
+          [css_name || name, value]
+        end
+      end
+    end
+    
+    %w(font_desc font_family face size style weight variant
+        stretch foreground background underline
+        underline_color rise strikethrough
+        strikethrough_color fallback lang).each do |name|
+      module_eval(<<-EOC)
+        class #{to_class_name(name)}
+          include SpanTextFormatter
+          
+          def name
+            #{name.dump}
+          end
+        end
+EOC
+    end
+
+    class Size
+      def initialize(value)
+        value = value.ceil if value.is_a?(Numeric)
+        super(value)
+      end
+    end
+    
+    class Foreground
+      def normalize_attribute(name, value)
+        value = Renderer::Color.parse(value).to_gdk_format
+        super(name, value)
+      end
+    end
+
+    module ConvenienceTextFormatter
+
+      include Formatter
+
+      def text_formatter?
+        true
+      end
+      
+      def html_formatter?
+        true
+      end
+      
+      def format(text)
+        tagged_text(text, name, {})
+      end
+
+      def html_format(text)
+        tagged_text(text, name, {})
+      end
+    end
+
+    %w(b big i s sub sup small tt u).each do |name|
+      module_eval(<<-EOC)
+        class #{to_class_name(name)}
+          include ConvenienceTextFormatter
+          
+          def name
+            #{name.dump}
+          end
+        end
+EOC
+    end
+  end
+end

data/lib/rabbit/frame.rb

@@ -0,0 +1,275 @@
+require "forwardable"
+require "gtk2"
+require "rexml/text"
+
+require "rabbit/rabbit"
+require "rabbit/utils"
+
+module Rabbit
+
+  class Frame
+
+    include ScreenInfo
+    extend Forwardable
+
+    FALLBACK_LIMIT = 250
+    
+    def_delegators(:@window, :icon, :icon=, :set_icon)
+    def_delegators(:@window, :icon_list, :icon_list=, :set_icon_list)
+    def_delegators(:@window, :iconify, :show, :hide, :visible?)
+    def_delegators(:@window, :set_size_request, :resize)
+
+    def_delegators(:@canvas, :apply_theme, :theme_name)
+    def_delegators(:@canvas, :saved_image_type=, :saved_image_base_name=)
+    def_delegators(:@canvas, :save_as_image, :each_slide_pixbuf)
+    def_delegators(:@canvas, :print, :filename=)
+    def_delegators(:@canvas, :output_html=, :output_index_html=)
+    def_delegators(:@canvas, :rss_base_uri=, :use_gl?, :use_gl=)
+
+    attr_reader :window, :logger
+    attr_accessor :geometry
+
+    def initialize(logger, canvas)
+      @logger = logger
+      @canvas = canvas
+      @geometry = nil
+    end
+
+    def destroyed?
+      @window.nil? or @window.destroyed?
+    end
+    
+    def quit
+      @window.destroy unless destroyed?
+      @window = nil
+      true
+    end
+
+    def width
+      @window.size[0]
+    end
+
+    def height
+      @window.size[1]
+    end
+
+    def parse(source, callback=nil, &block)
+      @canvas.parse(source, callback, &block)
+    end
+
+    def fullscreen
+      @fullscreen_toggled = false
+      @fullscreen = true
+      @window.fullscreen
+      fallback_fullscreen
+    end
+
+    def unfullscreen
+      @fullscreen_toggled = false
+      @fullscreen = false
+      @window.unfullscreen
+      fallback_unfullscreen
+    end
+    
+    def toggle_fullscreen
+      if fullscreen?
+        unfullscreen
+      else
+        fullscreen
+      end
+    end
+
+    def fullscreen?
+      if @window.respond_to?(:fullscreen?)
+        @window.fullscreen?
+      else
+        @fullscreen
+      end
+    end
+
+    def main_window?
+      @main_window
+    end
+    
+    def update_title(new_title)
+      @window.title = Utils.unescape_title(new_title)
+    end
+
+    def init_gui(width, height, main_window, window_type=nil)
+      init_window(width, height, window_type)
+      @fullscreen_toggled = false
+      @fullscreen = false
+      @iconify = false
+      @main_window = main_window
+      @window.keep_above = true unless @main_window
+      @window.show
+      @canvas.post_init_gui
+    end
+
+    def fullscreen_available?
+      true
+    end
+
+    def iconify_available?
+      true
+    end
+
+    private
+    def init_window(width, height, window_type=nil)
+      window_type ||= Gtk::Window::TOPLEVEL
+      @window = Gtk::Window.new(window_type)
+      @window.set_default_size(width, height)
+      @window.parse_geometry(@geometry) if @geometry
+      @window.set_app_paintable(true)
+      set_window_signal
+      setup_dnd
+      @canvas.attach_to(self, @window)
+    end
+
+    def set_window_signal
+      set_window_signal_window_state_event
+      set_window_signal_destroy
+    end
+
+    def set_window_signal_window_state_event
+      @window.signal_connect("window_state_event") do |widget, event|
+        if event.changed_mask.fullscreen?
+          @fullscreen_toggled = true
+          if fullscreen?
+            @window.keep_above = true
+            @canvas.fullscreened
+          else
+            @window.keep_above = !@main_window
+            @canvas.unfullscreened
+          end
+          @window.present
+        elsif event.changed_mask.iconified?
+          if @iconify
+            @iconify = false
+          else
+            @canvas.iconified
+            @iconify = true
+          end
+        end
+      end
+    end
+
+    def set_window_signal_destroy
+      @window.signal_connect("destroy") do
+        @canvas.detach
+        if main_window? and Gtk.main_level > 0
+          Gtk.main_quit
+        end
+      end
+    end
+
+    def setup_dnd
+      Gtk::Drag.dest_set(@window,
+                         Gtk::Drag::DEST_DEFAULT_ALL,
+                         [["text/uri-list", 0, 0],
+                          ["_NETSCAPE_URL", 0, 0]],
+                         Gdk::DragContext::ACTION_COPY)
+      @window.signal_connect("drag-data-received") do |*args|
+        widget, context, x, y, selection_data, info, time = args
+        uri = selection_data.data.chomp
+        Gtk.idle_add do
+          parse(Source::URI.new(nil, logger, uri))
+          false
+        end
+        Gtk::Drag.finish(context, true, false, time)
+      end
+
+      @window.signal_connect("drag-drop") do |widget, context, x, y, time|
+        true
+      end
+    end
+
+    def fallback_fullscreen
+      @prev_width = @prev_height = nil
+      @prev_x = @prev_y = nil
+      Gtk.timeout_add(FALLBACK_LIMIT) do
+        unless @fullscreen_toggled
+          @prev_width, @prev_height = width, height
+          @prev_x, @prev_y = @window.position
+          @window.hide
+          @window.set_size_request(screen_width, screen_height)
+          @window.decorated = false
+          @window.keep_above = true
+          @window.show
+          @window.move(0, 0)
+          @window.present
+          @canvas.fullscreened
+        end
+        false
+      end
+    end
+
+    def fallback_unfullscreen
+      Gtk.timeout_add(FALLBACK_LIMIT) do
+        if !@fullscreen_toggled and
+            @prev_width and @prev_height and
+            @prev_x and @prev_y
+          @window.hide
+          @window.set_size_request(@prev_width, @prev_height)
+          @window.decorated = true
+          @window.keep_above = !@main_window
+          @window.show
+          @window.move(@prev_x, @prev_y)
+          @window.present
+          @canvas.unfullscreened
+        end
+        false
+      end
+    end
+  end
+
+  class NullFrame
+    class << self
+      def def_null_methods(*names)
+        names.each do |name|
+          define_method(name) {|*args|}
+        end
+      end
+    end
+
+    def_null_methods(:icon, :icon=, :set_icon)
+    def_null_methods(:icon_list, :icon_list=, :set_icon_list)
+    def_null_methods(:update_title, :geometry, :geometry=)
+
+    def_null_methods(:fullscreen?, :quit)
+
+    def fullscreen_available?
+      false
+    end
+
+    def iconify_available?
+      false
+    end
+  end
+  
+  class EmbedFrame < Frame
+
+    def update_title(new_title)
+    end
+
+    def fullscreen_available?
+      false
+    end
+
+    def iconify_available?
+      false
+    end
+    
+    def init_gui(width, height, main_window, window_type=nil)
+      @window = Gtk::EventBox.new
+      @window.set_size_request(width, height)
+      @canvas.attach_to(self, @window)
+      @fullscreen_toggled = false
+      @fullscreen = false
+      @iconify = false
+      @main_window = main_window
+      @window.show
+      @canvas.post_init_gui
+    end
+  end
+end