jpeg2pdf 0.12

data/lib/rpdf/document.rb

@@ -0,0 +1,61 @@
+require 'rpdf/crossreftable'
+require 'rpdf/documentcatalog'
+require 'rpdf/pagetree'
+require 'rpdf/trailer'
+require 'rpdf/version'
+
+module RPDF
+  class Document
+    attr_reader :pdf_version, :pagetree, :root, :xrefs
+
+    def initialize(pdf, pdf_version = VERSION_DEFAULT)
+	  @pdf = pdf
+      @pdf_version = pdf_version
+      @objects = Array.new
+      @pagetree = PageTree.new(self)
+      @root = DocumentCatalog.new(self)
+      @xrefs = CrossRefTable.new
+	  
+	  # File Header [PDFRef15 p68]
+      bytes = @pdf_version.to_pdf
+      bytes << "����\n"  # Ensure file transfer applications detect the file as binary. [PDFRef15 p69]
+	  @numwritten = bytes.size
+	  @pdf.write(bytes)
+	  
+    end
+
+    def new_id(object)
+      @objects << object
+      @objects.size
+    end
+
+    def size
+      @objects.size
+    end
+
+    def write(object)
+	  objectbytes = object.to_pdf
+	  @xrefs.addUsedEntry(@numwritten, object.object_number) # position of the next object in the PDF file
+	  @pdf.write(objectbytes)
+	  @numwritten = @numwritten + objectbytes.size
+	end
+
+    def close_pdf
+      trailer = Trailer.new(self)
+	  bytes = String.new
+         
+      # File Body [PDFRef15 p69]
+      @objects.each { |object|
+		  object.invalidate	unless object.invalidated?
+      }
+
+      trailer.startxref = @numwritten
+
+      # Cross-Reference Table [PDFRef15 p69]
+      @pdf.write(@xrefs.to_pdf)
+
+      # File Trailer [PDFRef15 p72]
+      @pdf.write(trailer.to_pdf)
+    end
+  end
+end

data/lib/rpdf/documentcatalog.rb

@@ -0,0 +1,18 @@
+require 'rpdf/pdfdictionary'
+require 'rpdf/document'
+
+module RPDF
+
+  # Document Catalog Object
+  # [PDFRef15 p113]
+  class DocumentCatalog < PDFDictionary
+ 
+    def initialize(document)
+      super({ :Type => :Catalog, 
+              :Pages => document.pagetree }, 
+            document)
+    end
+
+  end
+
+end

data/lib/rpdf/imagedictionary.rb

@@ -0,0 +1,23 @@
+require 'rpdf/pdfdictionary'
+
+module RPDF
+
+  # Image Dictionary Object
+  # [PDFRef15 p303]
+  class ImageDictionary < PDFDictionary
+ 
+    # colorspace: :DeviceGrey, :DeviceRGB or :DeviceCMYK
+	# bpc: 8, 12 or 16
+    def initialize(width, height, colorspace, bpc, document=nil)
+      super({ :Type => :XObject,
+              :Subtype => :Image,
+              :Width => width,
+              :Height => height,
+              :ColorSpace => colorspace,
+              :BitsPerComponent => bpc }, 
+            document)
+    end
+
+  end
+
+end

data/lib/rpdf/page.rb

@@ -0,0 +1,21 @@
+require 'rpdf/pdfdictionary'
+
+module RPDF
+
+  # Page Object
+  # [PDFRef15 p118]
+  class Page < PDFDictionary
+ 
+    def initialize(document, parent)
+      super({ :Type => :Page,
+              :Parent => parent,
+              :Resources => {},
+              :MediaBox => Rectangle.new(0, 0, 612, 792) }, 
+            document)
+
+      parent.add_page(self)
+    end
+
+  end
+
+end

data/lib/rpdf/pagetree.rb

@@ -0,0 +1,24 @@
+require 'rpdf/pdfdictionary'
+
+module RPDF
+
+  # Page Tree Object
+  # [PDFRef15 p116]
+  class PageTree < PDFDictionary
+ 
+    def initialize(document, parent=nil)
+      super({ :Type => :Pages,
+              :Parent => parent,
+              :Kids => [],
+              :Count => 0 }, 
+            document)
+    end
+
+    def add_page(page)
+      self[:Kids] << page
+      self[:Count] = self[:Count].value + 1
+    end
+
+  end
+
+end

data/lib/rpdf/pdfarray.rb

@@ -0,0 +1,35 @@
+require 'rpdf/pdfobject'
+require 'rpdf/util'
+
+module RPDF
+
+  # Array Object
+  # [PDFRef15 p34]
+  class PDFArray < PDFObject
+    attr_reader :array
+ 
+    def initialize(array, document=nil)
+      raise Exception.new("PDFArray is not an array") unless array.kind_of?(Array)
+      @array = Array.new
+      array.each { |object|
+        @array << RPDF.topdfobject(object, document)
+      }
+      super(document)
+    end
+
+    def <<(element)
+      @array << RPDF.topdfobject(element)
+    end
+
+    def to_s
+      bytes = "[ "
+      @array.each { |element|
+        bytes << element.to_ref # to_ref -> reference to indirect object
+        bytes << " "
+      }
+      bytes << "]"
+    end
+
+  end
+
+end

data/lib/rpdf/pdfboolean.rb

@@ -0,0 +1,28 @@
+require 'rpdf/pdfobject'
+
+module RPDF
+
+  # Boolean Object: true or false
+  # [PDFRef15 p28]
+  class PDFBoolean < PDFObject
+    include Comparable
+
+    attr_reader :value
+
+    def initialize(value, document=nil)
+      raise Exception.new("PDFBoolean not true nor false") unless (value.kind_of?(TrueClass) or value.kind_of?(FalseClass))
+      @value = value
+      super(document)
+    end
+
+    def <=>(other)
+      @value <=> other.value
+    end
+
+    def to_s
+      @value.to_s
+    end
+
+  end
+
+end

data/lib/rpdf/pdfdictionary.rb

@@ -0,0 +1,51 @@
+require 'rpdf/pdfobject'
+require 'rpdf/util'
+
+module RPDF
+
+  # Dictionary Object
+  # [PDFRef15 p35]
+  class PDFDictionary < PDFObject
+    attr_reader :dict
+ 
+    def initialize(dict, document=nil)
+      raise Exception.new("PDFDictionary is not a hash") unless dict.kind_of?(Hash)
+      @dict = Hash.new
+      dict.each { |key, value|
+        pdfkey = RPDF.topdfobject(key)
+        pdfvalue = RPDF.topdfobject(value)
+        raise Exception.new("PDFDictionary key must be a name") unless pdfkey.kind_of?(PDFName)
+        @dict[pdfkey] = pdfvalue
+      }
+      super(document)
+    end
+
+    def [](key)
+      pdfkey = RPDF.topdfobject(key)
+      raise Exception.new("PDFDictionary key must be a name") unless pdfkey.kind_of?(PDFName)
+      @dict[pdfkey]
+    end
+
+    def []=(key, value)
+      pdfkey = RPDF.topdfobject(key)
+      pdfvalue = RPDF.topdfobject(value)
+      raise Exception.new("PDFDictionary key must be a name") unless pdfkey.kind_of?(PDFName)
+      @dict[pdfkey] = pdfvalue
+    end
+
+    # Update dictionary with other dictionary
+    def update(other)
+      @dict.update(other.dict)
+    end
+
+    def to_s
+      bytes = "<< "
+      @dict.each { |key, value|
+        bytes << "#{key.to_s} #{value.to_ref}\n" # to_ref -> reference to indirect object
+      }
+      bytes << ">>\n"
+    end
+
+  end
+
+end

data/lib/rpdf/pdfinteger.rb

@@ -0,0 +1,17 @@
+require 'rpdf/pdfnumeric'
+
+module RPDF
+
+  # Integer Object
+  # This is not a real PDF Object, as PDF knows only Numerics.
+  # [PDFRef15 p28]
+  class PDFInteger < PDFNumeric
+
+    def initialize(value, document=nil)
+      raise Exception.new("PDFInteger is not an integer") unless value.kind_of?(Integer)
+      super
+    end
+
+  end
+
+end

data/lib/rpdf/pdfname.rb

@@ -0,0 +1,35 @@
+require 'rpdf/pdfobject'
+require 'rpdf/util'
+
+module RPDF
+
+  # Name Object
+  # [PDFRef15 p32]
+  class PDFName < PDFObject
+    attr_reader :value
+ 
+    def initialize(value, document=nil)
+      raise Exception.new("PDFName is not a string") unless value.kind_of?(String)
+      raise Exception.new("PDFName has whitespace") if RPDF.includes_whitespace?(value)
+      raise Exception.new("PDFName has delimiter") if RPDF.includes_delimiter?(value)
+      @value = value
+      super(document)
+    end
+
+    def hash
+      @value.hash
+    end
+
+    # To make PDFName possible to use as a key in a PDFDictionary
+    def eql?(other)
+      @value.eql?(other.value)
+    end
+
+    # TODO: 2-digit hexadecimal code for characters outside the range 33 (!) to 126 (~) [PDFRef15 p33]
+    def to_s
+      "/#{@value}"
+    end
+
+  end
+
+end

data/lib/rpdf/pdfnull.rb

@@ -0,0 +1,19 @@
+require 'rpdf/pdfobject'
+
+module RPDF
+
+  # Null Object: null
+  # [PDFRef15 p39]
+  class PDFNull < PDFObject
+
+    def initialize
+      super
+    end
+
+    def to_s
+      "null"
+    end
+
+  end
+
+end

data/lib/rpdf/pdfnumeric.rb

@@ -0,0 +1,28 @@
+require 'rpdf/pdfobject'
+
+module RPDF
+
+  # Numeric Object
+  # [PDFRef15 p28]
+  class PDFNumeric < PDFObject
+    include Comparable
+
+    attr_reader :value
+
+    def initialize(value, document=nil)
+      raise Exception.new("PDFNumeric is not a number") unless value.kind_of?(Numeric)
+      @value = value
+      super(document)
+    end
+
+    def <=>(other)
+      @value <=> other.value
+    end
+
+    def to_s
+      @value.to_s
+    end
+
+  end
+
+end

data/lib/rpdf/pdfobject.rb

@@ -0,0 +1,60 @@
+module RPDF
+
+  # An object which is a part of a PDF document. [PDFRef15 p27]
+  class PDFObject
+
+    attr_reader :object_number, :generation_number
+
+    # Make an indirect object if a document is passed, otherwise a direct object.
+    def initialize(document=nil)
+      if document
+        @object_number = document.new_id(self)
+        @document = document
+      else
+        @object_number = 0 # The object number of an indirect object should be positive
+      end
+      @generation_number = 0
+      @invalidated = false
+    end
+
+    def indirect?
+      @object_number > 0
+    end
+	
+	# Subclasses has to call this in their invalidate method if they override it
+	def invalidate
+	  @document.write(self)
+          @invalidated = true
+	end
+	
+	# true if the object has already been written to the PDF stream
+	def invalidated?
+	  @invalidated
+	end
+
+    # Return a representation suitable to write to a PDF file
+    # [PDFRef15 p39]
+    def to_pdf
+      if indirect?
+        bytes = "#{@object_number} #{@generation_number} obj\n"
+        bytes << to_s << "\n"
+        bytes << "endobj\n\n"
+      else
+        to_s
+      end
+    end
+
+    # Return an indirect reference to this object if it's indirect,
+    # return the bytestream otherwise.
+    # [PDFRef15 p39]
+    def to_ref
+      if indirect?
+        "#{@object_number} #{@generation_number} R"
+      else
+        to_s
+      end
+    end
+
+  end
+
+end

data/lib/rpdf/pdfstream.rb

@@ -0,0 +1,32 @@
+require 'rpdf/pdfdictionary'
+require 'rpdf/pdfobject'
+
+module RPDF
+
+  # Stream Object
+  # TODO: stream dictionary
+  # [PDFRef15 p36]
+  class PDFStream < PDFObject
+    attr_reader :data, :dict
+ 
+    def initialize(data, document=nil)
+      @data = data
+      @dict = PDFDictionary.new({ :Length => data.size })
+      super(document)
+    end
+
+    def invalidate
+	  super
+	  @data = nil
+	end
+
+    def to_s
+      bytes = @dict.to_pdf
+      bytes << "stream\n"
+      bytes << data
+      bytes << "\nendstream"
+    end
+
+  end
+
+end