eideticpdf 0.9.9

data/lib/epdfs.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+# encoding: ASCII-8BIT
+#
+#  Created by Brent Rowland on 2008-01-12.
+#  Copyright (c) 2008, Eidetic Software. All rights reserved.
+
+# Eidetic PDF Support
+
+class Numeric # :nodoc:
+  unless 1.respond_to?(:degrees)
+    def degrees
+      self * Math::PI / 180
+    end
+  end
+
+  unless 2.respond_to?(:even?)
+    def even?
+      self % 2 == 0
+    end
+  end
+
+  unless 1.respond_to?(:odd?)
+    def odd?
+      self % 2 != 0
+    end
+  end
+end
+
+module EideticPDF
+  ImageReadMode = "".respond_to?(:encoding) ? "rb:binary" : "rb"
+
+  module Statistics # :nodoc:
+    def sum
+      self.inject(0) { |total, obj| total + obj }
+    end
+
+    def mean
+      self.sum.quo(self.size)
+    end
+  end
+
+  class PropertyStack # :nodoc:
+    def initialize(obj, prop, &block)
+      @obj, @prop, @condition = obj, prop, block
+      @stack = []
+    end
+
+    def push(value)
+      @stack.push @obj.send(@prop)
+      @obj.send(@prop, value) if @condition.call(value)
+    end
+
+    def pop
+      value = @stack.pop
+      @obj.send(@prop, value) if @condition.call(value)
+    end
+  end
+
+  class ColorStack # :nodoc:
+    def initialize(obj, prop)
+      @obj, @prop = obj, prop
+      @stack = []
+    end
+
+    def push(color)
+      @stack.push @obj.send(@prop)
+      @obj.send(@prop, color) if color.respond_to?(:to_int) or color.respond_to?(:to_str)
+    end
+
+    def pop
+      color = @stack.pop
+      @obj.send(@prop, color) if color.respond_to?(:to_int) or color.respond_to?(:to_str)
+    end
+  end
+
+  module JpegInfo # :nodoc:
+    def jpeg?(image)
+      # image[0, 2] == "\xFF\xD8"
+      image[0, 2].hash == "\xFF\xD8".hash
+    end
+
+    def jpeg_dimensions(image)
+      raise ArgumentError, "Not a JPEG" unless jpeg?(image)
+      image = image.dup
+      image.slice!(0, 2) # delete jpeg marker
+      while marker = image.slice!(0, 4)
+        m, c, l = marker.unpack('aan')
+        raise "Bad JPEG" unless m == "\xFF"
+        if ["\xC0", "\xC1", "\xC2", "\xC3", "\xC5", "\xC6", "\xC7", "\xC9", "\xCA", "\xCB", "\xCD", "\xCE", "\xCF"].include?(c)
+          dims = image.slice(0, 6)
+          bits_per_component, height, width, components = dims.unpack('CnnC')
+          break
+        end
+        image.slice!(0, l - 2)
+      end
+      [width, height, components, bits_per_component]
+    end
+    
+    module_function :jpeg?, :jpeg_dimensions
+  end
+end

data/lib/epdfsw.rb

@@ -0,0 +1,267 @@
+#!/usr/bin/env ruby
+# encoding: ASCII-8BIT
+#
+#  Created by Brent Rowland on 2007-07-13.
+#  Copyright (c) 2007, 2008 Eidetic Software. All rights reserved.
+#
+# Eidetic PDF Stream Writers
+
+require 'epdfo'
+
+module EideticPDF
+  class BaseWriter # :nodoc:
+    def f(value, prec=2)
+      sprintf("%.*f", prec, value).sub(',','.')
+    end
+
+    def g(value, prec=4)
+      # prec must be >= 1 or gsub will strip significant trailing 0's.
+      sprintf("%.*f", prec, value).sub(',','.').gsub(/\.?0*$/,'')
+    end
+  end
+
+  class MiscWriter < BaseWriter # :nodoc:
+    def initialize(stream)
+      @stream = stream
+    end
+
+    def set_gray_fill(gray)
+      @stream << "%s g\n" % g(gray)
+    end
+
+    def set_gray_stroke(gray)
+      @stream << "%s G\n" % g(gray)
+    end
+
+    def set_cmyk_color_fill(c, m, y, k)
+      @stream << "%s %s %s %s k\n" % [g(c), g(m), g(y), g(k)]
+    end
+
+    def set_cmyk_color_stroke(c, m, y, k)
+      @stream << "%s %s %s %s K\n" % [g(c), g(m), g(y), g(k)]
+    end
+
+    def set_rgb_color_fill(red, green, blue)
+      @stream << "%s %s %s rg\n" % [g(red), g(green), g(blue)]
+    end
+
+    def set_rgb_color_stroke(red, green, blue)
+      @stream << "%s %s %s RG\n" % [g(red), g(green), g(blue)]
+    end
+
+    def set_color_space_fill(name)
+      @stream << "/#{name} cs\n"
+    end
+
+    def set_color_space_stroke(name)
+      @stream << "/#{name} CS\n"
+    end
+
+    def set_color_fill(colors)
+      @stream << "%s sc\n" % colors.map { |c| g(c) }.join(' ')
+    end
+
+    def set_color_stroke(colors)
+      @stream << "%s SC\n" % colors.map { |c| g(c) }.join(' ')
+    end
+
+    # xxx scn, SCN: patterns and separations
+    def set_color_rendering_intent(intent)
+      @stream << "/#{intent} ri\n"
+    end
+
+    def x_object(name)
+      @stream << "/#{name} Do\n"
+    end
+  end
+
+  class GraphWriter < BaseWriter # :nodoc:
+    def initialize(stream)
+      @stream = stream
+    end
+
+    def save_graphics_state
+      @stream << "q\n"
+    end
+
+    def restore_graphics_state
+      @stream << "Q\n"
+    end
+
+    def concat_matrix(a, b, c, d, x, y)
+      @stream << "%s %s %s %s %s %s cm\n" % [g(a), g(b), g(c), g(d), g(x), g(y)]
+    end
+
+    def set_flatness(flatness)
+      @stream << "%d i\n" % flatness
+    end
+
+    def set_line_cap_style(line_cap_style)
+      @stream << "%d J\n" % line_cap_style
+    end
+
+    def set_line_dash_pattern(line_dash_pattern)
+      @stream << "%s d\n" % line_dash_pattern
+    end
+
+    def set_line_join_style(line_join_style)
+      @stream << "%d j\n" % line_join_style
+    end
+
+    def set_line_width(line_width)
+      @stream << "%s w\n" % g(line_width)
+    end
+
+    def set_miter_limit(miter_limit)
+      @stream << "%s M\n" % g(miter_limit)
+    end
+
+    def move_to(x, y)
+      @stream << "%s %s m\n" % [g(x), g(y)]
+    end
+
+    def line_to(x, y)
+      @stream << "%s %s l\n" % [g(x), g(y)]
+    end
+
+    def curve_to(x1, y1, x2, y2, x3, y3)
+      @stream << "%s %s %s %s %s %s c\n" % [g(x1), g(y1), g(x2), g(y2), g(x3), g(y3)]
+    end
+
+    def rectangle(x, y, width, height)
+      @stream << "%s %s %s %s re\n" % [g(x), g(y), g(width), g(height)]
+    end
+
+    def close_path
+      @stream << "h\n"
+    end
+
+    def new_path
+      @stream << "n\n"
+    end
+
+    def stroke
+      @stream << "S\n"
+    end
+
+    def close_path_and_stroke
+      @stream << "s\n"
+    end
+
+    def fill
+      @stream << "f\n"
+    end
+
+    def eo_fill
+      @stream << "f*\n"
+    end
+
+    def fill_and_stroke
+      @stream << "B\n"
+    end
+
+    def close_path_fill_and_stroke
+      @stream << "b\n"
+    end
+
+    def eo_fill_and_stroke
+      @stream << "B*\n"
+    end
+
+    def close_path_eo_fill_and_stroke
+      @stream << "b*\n"
+    end
+
+    # use nonzero winding number rule
+    def clip
+      @stream << "W\n"
+    end
+
+    # use even-odd rule
+    def eo_clip
+      @stream << "W*\n"
+    end
+
+    def make_line_dash_pattern(pattern, phase)
+      "[%s] %d" % [pattern.join(' '), phase]
+    end
+  end  
+
+  class TextWriter < BaseWriter # :nodoc:
+    def initialize(stream)
+      @stream = stream
+    end
+    
+    def open
+      @stream << "BT\n"
+    end
+    
+    def close
+      @stream << "ET\n"
+    end
+
+    def set_char_spacing(char_space)
+      @stream << "%s Tc\n" % g(char_space)
+    end
+
+    def set_word_spacing(word_space)
+      @stream << "%s Tw\n" % g(word_space)
+    end
+
+    def set_horiz_scaling(scale)
+      @stream << "%s Tz\n" % g(scale)
+    end
+
+    def set_leading(leading)
+      @stream << "%s TL\n" % g(leading)
+    end
+
+    def set_font_and_size(font_name, size)
+      @stream << "/%s %s Tf\n" % [font_name, g(size)]
+    end
+
+    def set_rendering_mode(render)
+      @stream << "%d Tr\n" % render
+    end
+
+    def set_rise(rise)
+      @stream << "%s Ts\n" % g(rise)
+    end
+
+    def move_by(tx, ty)
+      @stream << "%s %s Td\n" % [g(tx), g(ty)]
+    end
+
+    def move_by_and_set_leading(tx, ty)
+      @stream << "%s %s TD\n" % [g(tx), g(ty)]
+    end
+
+    def set_matrix(a, b, c, d, x, y)
+      @stream << "%s %s %s %s %s %s Tm\n" % [g(a), g(b), g(c), g(d), g(x), g(y)]
+    end
+
+    def next_line
+      @stream << "T*\n"
+    end
+
+    def show(s)
+      @stream << "(%s) Tj\n" % PdfObjects::PdfString.escape(s)
+    end
+
+    def show_wide(ws)
+      @stream << "(%s) Tj\n" % PdfObjects::PdfString.escape_wide(ws)
+    end
+
+    def next_line_show(s)
+      @stream << "(%s) '" % PdfObjects::PdfString.escape(s)
+    end
+
+    def set_spacing_next_line_show(char_space, word_space, s)
+      @stream << "%s %s (%s) \"\n" % [g(char_space), g(word_space), PdfObjects::PdfString.escape(s)]
+    end
+
+    def show_with_dispacements(elements)
+      @stream << "%sTJ\n" % elements
+    end
+  end
+end

data/lib/epdft.rb

@@ -0,0 +1,145 @@
+#!/usr/bin/env ruby
+# encoding: ASCII-8BIT
+#
+#  Created by Brent Rowland on 2007-11-27.
+#  Copyright (c) 2007, Eidetic Software. All rights reserved.
+
+module EideticPDF
+  module TextLine # :nodoc:
+    def height
+      @height ||= map { |p| 0.001 * p.font.height * p.font.size }.max
+    end
+
+    def ascent
+      @ascent ||= map { |p| 0.001 * p.font.ascent * p.font.size }.max
+    end
+
+    def descent
+      @descent ||= map { |p| 0.001 * p.font.descent * p.font.size }.min
+    end
+
+    def width
+      @width ||= inject(0) { |total, p| total + p.width }
+    end
+
+    def chars
+      @chars ||= inject(0) { |total, p| total + p.chars }
+    end
+
+    def tokens
+      @tokens ||= inject(0) { |total, p| total + p.tokens }
+    end
+  end
+
+  module PdfText # :nodoc: all
+    class TextPiece
+      attr_accessor :text, :width, :font, :color, :underline, :chars, :tokens
+
+      def initialize(text, width, font, color, underline, chars, tokens)
+        @text, @width, @font, @color, @underline, @chars, @tokens = text, width, font, color, underline, chars, tokens
+      end
+
+      def initialize_copy(other)
+        @text = @text.clone
+      end
+    end
+
+    class RichText
+      TOKEN_RE = /\n|\t|[ ]|[\S]+-+|[\S]+/
+      attr_reader :words
+
+      def initialize(text=nil, font=nil, options={})
+        @words = []
+        add(text, font, options) unless text.nil?
+      end
+
+      def initialize_copy(other)
+        @words = @words.map { |word| word.clone }
+      end
+
+      def add(text, font, options={})
+        fsize = font.size * 0.001
+        char_spacing, word_spacing = options[:char_spacing] || 0, options[:word_spacing] || 0
+        color, underlined = options[:color] || 0, options[:underline] || false
+        words = text.scan(TOKEN_RE).map do |token|
+          width = 0.0
+          token.each_byte do |b|
+            width += fsize * font.widths[b] + char_spacing
+            width += word_spacing if b == 32 # space
+          end
+          TextPiece.new(token, width, font, color, underlined, token.length, 1)
+        end
+        @words.concat(words)
+      end
+
+      # merge pieces with identical characteristics
+      def merge(text_pieces)
+        while !text_pieces.empty? and text_pieces.last.text == ' '
+          text_pieces.pop
+        end
+        text_pieces.inject([]) do |pieces, piece|
+          if pieces.empty? or [pieces.last.font, pieces.last.color, pieces.last.underline] != [piece.font, piece.color, piece.underline]
+            pieces << piece
+          else
+            pieces.last.text << piece.text
+            pieces.last.width += piece.width
+            pieces.last.chars += piece.chars
+            pieces.last.tokens += piece.tokens
+          end
+          pieces
+        end
+      end
+
+      def next(width)
+        # remove leading spaces
+        @words.shift while !@words.empty? and @words.first.text == ' '
+        return nil if @words.empty?
+        # measure how many words will fit
+        i, phrase_width = 0, 0.0
+        while i < @words.size and phrase_width + @words[i].width < width
+          phrase_width += @words[i].width
+          i += 1
+          break if @words[i-1].text == "\n"
+        end
+        merge(@words.slice!(0, [i,1].max)).extend(TextLine)
+      end
+
+      def lines(width)
+        rich_text = self.clone
+        result = []
+        while line = rich_text.next(width)
+          result << line
+        end
+        result
+      end
+
+      def empty?
+        @words.empty?
+      end
+
+      def ascent(width=nil)
+        return 0 if @words.empty?
+        if width.nil?
+          @words.clone.extend(TextLine).ascent
+        else
+          self.clone.next(width).ascent
+        end
+      end
+
+      def height(width=nil)
+        return 0 if @words.empty?
+        if width.nil?
+          @words.clone.extend(TextLine).height
+          # f = @words.first.font
+          # 0.001 * f.height * f.size
+        else
+          lines(width).inject(0) { |total, line| total + line.height }
+        end
+      end
+
+      def width(max_width)
+        lines(max_width).map { |line| line.width }.max
+      end
+    end
+  end
+end