pdftoruby 0.0.4

data/History.txt

@@ -0,0 +1,8 @@
+=== 0.0.4 / 2008-05-20
+
+* 3 major enhancement
+
+  * Added support for SVN version of PDF::Reader using hash to get image parameters
+  * Added support for writing png files
+  * Added internal version of png library to allow fixes, changes, and hardwire it to pure ruby
+

data/Manifest.txt

@@ -0,0 +1,8 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/pdftoruby.rb
+lib/dumppdf.rb
+lib/pdf-extended-ops.rb
+lib/pdftoruby.rb

data/README.txt

@@ -0,0 +1,56 @@
+= pdftoruby
+
+* http://code.google.com/p/pdftoruby/
+
+== DESCRIPTION:
+
+Convert pdf files into ruby classes - allow creation of complex pdf files from existing pdf files
+
+== FEATURES/PROBLEMS:
+
+Support for text
+Support for Line Graphics
+Support for Images (Indexed Color)
+
+Problems:
+JPG Embedded Images not supported
+
+== SYNOPSIS:
+
+  pdftoruby.rb mypdf.pdf mypdf.rb MyPdf
+
+Will read mypdf.pdf and create mypdf.rb with a Class of MyPdf.
+A subdirectory of the name MyPdf will be created with resources.
+
+
+== REQUIREMENTS:
+
+PDF::Reader (Currently from SVN as of May 20, 2008
+PDF::Writer
+
+== INSTALL:
+
+gem install pdftoruby
+
+== LICENSE:
+
+Copyright (c) 2008 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,12 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/pdftoruby.rb'
+
+Hoe.new('pdftoruby', Pdftoruby::VERSION) do |p|
+  p.rubyforge_name = 'pdftoruby' # if different than lowercase project name
+  p.developer('glennswest', 'glennswest@yahoo.com.sg')
+end
+
+# vim: syntax=Ruby

data/bin/pdftoruby.rb

@@ -0,0 +1,632 @@
+require 'rubygems'
+require 'pdf/reader'
+require 'pdf/writer'
+require 'base64'
+require 'zlib'
+require 'pp'
+
+$KCODE = 'u'
+require 'jcode'
+require 'iconv'
+require 'base64'
+
+class String # :nodoc:
+  ##
+  # Calculates a CRC using the algorithm in the PNG specification.
+  def png_crc
+    unless defined? @@crc then
+      @@crc = Array.new(256)
+      256.times do |n|
+        c = n
+        8.times do
+          c = (c & 1 == 1) ? 0xedb88320 ^ (c >> 1) : c >> 1
+        end
+        @@crc[n] = c
+      end
+    end
+
+    c = 0xffffffff
+    each_byte do |b|
+      c = @@crc[(c^b) & 0xff] ^ (c >> 8)
+    end
+    return c ^ 0xffffffff
+  end
+
+end
+
+## gsw - Make sure we have version 1 - as version 2 will require major havoc - also fix the "binary" issue
+# A pure Ruby Portable Network Graphics (PNG) writer.
+#
+# http://www.libpng.org/pub/png/spec/1.2/
+#
+# PNG supports:
+# + 8 bit truecolor PNGs
+#
+# PNG does not support:
+# + any other color depth
+# + extra data chunks
+# + filters
+#
+# = Example
+#
+#   require 'png'
+#   
+#   canvas = PNG::Canvas.new 200, 200
+#   canvas[100, 100] = PNG::Color::Black
+#   canvas.line 50, 50, 100, 50, PNG::Color::Blue
+#   png = PNG.new canvas
+#   png.save 'blah.png'
+
+class PNG
+
+  ##
+  # Creates a PNG chunk of type +type+ that contains +data+.
+
+  def self.chunk(type, data="")
+    [data.size, type, data, (type + data).png_crc].pack("Na*a*N")
+  end
+
+  ##
+  # Creates a new PNG object using +canvas+
+
+  def initialize(canvas)
+    @height = canvas.height
+    @width = canvas.width
+    @bits = 8
+    @data = canvas.data
+  end
+
+  ##
+  # Writes the PNG to +path+.
+
+  def save(path)
+    File.open(path, "wb") do |f|
+      f.write [137, 80, 78, 71, 13, 10, 26, 10].pack("C*") # PNG signature
+      f.write PNG.chunk('IHDR',
+                        [ @height, @width, @bits, 2, 0, 0, 0 ].pack("N2C5"))
+      # 0 == filter type code "none"
+      data = @data.map { |row| [0] + row.map { |p| [p.values[0], p.values[1], p.values[2]] } }.flatten
+      #data = @data.map { |row| [0] + row.map { |p| p.values } }.flatten
+      f.write PNG.chunk('IDAT', Zlib::Deflate.deflate(data.pack("C*"), 9))
+      f.write PNG.chunk('IEND', '')
+    end
+  end
+
+  ##
+  # RGBA colors
+
+  class Color
+
+    attr_reader :values
+
+    ##
+    # Creates a new color with values +red+, +green+, +blue+, and +alpha+.
+
+    def initialize(red, green, blue, alpha)
+      @values = [red, green, blue, alpha]
+    end
+
+    ##
+    # Transparent white
+
+    Background = Color.new 0xFF, 0xFF, 0xFF, 0x00
+ 
+    White      = Color.new 0xFF, 0xFF, 0xFF, 0xFF
+    Black      = Color.new 0x00, 0x00, 0x00, 0xFF
+    Gray       = Color.new 0x7F, 0x7F, 0x7F, 0xFF
+
+    Red        = Color.new 0xFF, 0x00, 0x00, 0xFF
+    Orange     = Color.new 0xFF, 0xA5, 0x00, 0xFF
+    Yellow     = Color.new 0xFF, 0xFF, 0x00, 0xFF
+    Green      = Color.new 0x00, 0xFF, 0x00, 0xFF
+    Blue       = Color.new 0x00, 0x00, 0xFF, 0xFF
+    Purple     = Color.new 0XFF, 0x00, 0xFF, 0xFF
+
+    ##
+    # Red component
+
+    def r; @values[0]; end
+
+    ##
+    # Green component
+
+    def g; @values[1]; end
+
+    ##
+    # Blue component
+
+    def b; @values[2]; end
+
+    ##
+    # Alpha transparency component
+
+    def a; @values[3]; end
+
+    ##
+    # Blends +color+ into this color returning a new blended color.
+
+    def blend(color)
+      return Color.new((r * (0xFF - color.a) + color.r * color.a) >> 8,
+                       (g * (0xFF - color.a) + color.g * color.a) >> 8,
+                       (b * (0xFF - color.a) + color.b * color.a) >> 8,
+                       (a * (0xFF - color.a) + color.a * color.a) >> 8)
+    end
+
+    ##
+    # Returns a new color with an alpha value adjusted by +i+.
+
+    def intensity(i)
+      return Color.new(r,b,g,(a*i) >> 8)
+    end
+
+    def inspect # :nodoc:
+      "#<%s %02x %02x %02x %02x>" % [self.class, *@values]
+    end
+
+  end
+
+  ##
+  # PNG canvas
+
+  class Canvas
+
+    ##
+    # Height of the canvas
+
+    attr_reader :height
+
+    ##
+    # Width of the canvas
+
+    attr_reader :width
+
+    ##
+    # Raw data
+
+    attr_reader :data
+
+    def initialize(height, width, background = Color::White)
+      @height = height
+      @width = width
+      @data = Array.new(@width) { |x| Array.new(@height) { background } }
+    end
+
+    ##
+    # Retrieves the color of the pixel at (+x+, +y+).
+
+    def [](x, y)
+      raise "bad x value #{x} >= #{@height}" if x >= @height
+      raise "bad y value #{y} >= #{@width}" if y >= @width
+      @data[y][x]
+    end
+
+    ##
+    # Sets the color of the pixel at (+x+, +y+) to +color+.
+
+    def []=(x, y, color)
+      raise "bad x value #{x} >= #{@height}" if x >= @height
+      raise "bad y value #{y} >= #{@width}"  if y >= @width
+      @data[y][x] = color
+    end
+
+    ##
+    # Iterates over each pixel in the canvas.
+
+    def each
+      @data.each_with_index do |row, y|
+        row.each_with_index do |pixel, x|
+          yield x, y, color
+        end
+      end
+    end
+
+    ##
+    # Blends +color+ onto the color at point (+x+, +y+).
+
+    def point(x, y, color)
+      self[x,y] = self[x,y].blend(color)
+    end
+
+    ##
+    # Draws a line using Xiaolin Wu's antialiasing technique.
+    #
+    # http://en.wikipedia.org/wiki/Xiaolin_Wu's_line_algorithm
+
+    def line(x0, y0, x1, y1, color)
+      dx = x1 - x0
+      sx = dx < 0 ? -1 : 1
+      dx *= sx # TODO: abs?
+      dy = y1 - y0
+
+      # 'easy' cases
+      if dy == 0 then
+        Range.new(*[x0,x1].sort).each do |x|
+          point(x, y0, color)
+        end
+        return
+      end
+
+      if dx == 0 then
+        (y0..y1).each do |y|
+          point(x0, y, color)
+        end
+        return
+      end
+
+      if dx == dy then
+        Range.new(*[x0,x1].sort).each do |x|
+          point(x, y0, color)
+          y0 += 1
+        end
+        return
+      end
+
+      # main loop
+      point(x0, y0, color)
+      e_acc = 0
+      if dy > dx then # vertical displacement
+        e = (dx << 16) / dy
+        (y0...y1-1).each do |i|
+          e_acc_temp, e_acc = e_acc, (e_acc + e) & 0xFFFF
+          x0 = x0 + sx if (e_acc <= e_acc_temp) 
+          w = 0xFF-(e_acc >> 8)
+          point(x0, y0, color.intensity(w))
+          y0 = y0 + 1
+          point(x0 + sx, y0, color.intensity(0xFF-w))
+        end
+        point(x1, y1, color)
+        return
+      end
+
+      # horizontal displacement
+      e = (dy << 16) / dx
+      (x0...(x1-sx)).each do |i|
+        e_acc_temp, e_acc = e_acc, (e_acc + e) & 0xFFFF
+        y0 += 1 if (e_acc <= e_acc_temp)
+        w = 0xFF-(e_acc >> 8)
+        point(x0, y0, color.intensity(w))
+        x0 += sx
+        point(x0, y0 + 1, color.intensity(0xFF-w))
+      end
+      point(x1, y1, color)
+    end
+
+  end
+
+end
+
+
+
+class PDFReceiver < PDF::Reader
+#    def init_xref(xref)
+#        @xref = xref
+#        end
+
+    def initextclass(thefile, theclass)
+        @ruby = thefile
+        @rubyclass = theclass
+        @text_position_x = 0.0
+        @text_position_y = 0.0
+        @text_font = "F1"
+        @text_size = 10.0
+        @ruby.printf("require 'pdf/writer'\n")
+        @ruby.printf("if File.exists?(\"../lib/pdf-extended-ops.rb\")\n")
+        @ruby.printf("   require '../lib/pdf-extended-ops.rb'\n")
+        @ruby.printf("  else \n")
+        @ruby.printf("   require 'pdf-extended-ops.rb'\n")
+        @ruby.printf("  end\n")
+        @ruby.printf("class %s\n",@rubyclass.capitalize)
+        @ruby.printf("def initialize()\n")
+        @ruby.printf("end\n")
+        @ruby.printf("\n\n")
+        @ruby.printf("def rendertofile(thename)\n")
+        @ruby.printf("    File.open(thename,\"wb\"){ |f| f.write @pdf.render }\n")
+        @ruby.printf("    end\n\n")
+        @ruby.printf("def createpage()\n")
+        end
+
+    def begin_document(args)
+        end
+
+    def begin_page(values)
+        pp values
+        rotate_value = values[:Rotate]
+        media_box = values[:MediaBox]
+        pp rotate_value
+        if rotate_value == 90.0
+           mypaper = ":paper => [#{media_box[0]}, #{media_box[1]}, #{media_box[2]}, #{media_box[3]}]"
+           pp mypaper
+           # @ruby.printf("    @pdf = PDF::Writer.new(:orientation => :landscape,#{mypaper})\n")
+           @ruby.printf("    @pdf = PDF::Writer.new(#{mypaper})\n")
+          else 
+           mypaper = ":paper => [#{media_box[0]}, #{media_box[1]}, #{media_box[2]}, #{media_box[3]}]"
+           pp mypaper
+           @ruby.printf("    @pdf = PDF::Writer.new(#{mypaper})\n")
+           end
+        #@ruby.printf("    @pdf = PDF::Writer.new\n")
+        #@ruby.printf("    @pdf.select_font (\"Helvetica\", { :encoding => \"WinAnsiEncoding\" })\n")
+        
+        #thefile = File.open("test.img","w")
+        #ithefile.write(therawbytes)
+        #thefile.close
+        end
+
+    def begin_page_container(values)
+        @pagemediabox  = values["MediaBox"]
+        @pageresources = values["Resources"]
+        @pagekids      = values["Kids"]
+        @pagetype      = values["Type"]
+        end
+
+    def begin_marked_content_with_pl(flag,mcid)
+        mcid.each do |key, value|
+           @ruby.printf("    @pdf.begin_marked_content_with_p1(\"#{flag}\",\"#{key}\",\"#{value}\")\n")
+           end
+        end
+
+    #{:name=>:set_gray_for_stroking, :args=>[0.0]}
+    def set_gray_for_stroking(value)
+        @ruby.printf("    @pdf.set_gray_for_stroking(#{value})\n")
+        end
+
+    #{:name=>:set_line_width, :args=>[0.72]}
+    def set_line_width(value)
+        @ruby.printf("    @pdf.set_line_width(#{value})\n")
+        end
+
+    #{:name=>:set_miter_limit, :args=>[10.0]}
+    def set_miter_limit(value)
+        @ruby.printf("    @pdf.set_miter_limit(#{value})\n")
+        end
+
+    #{:name=>:set_line_join_style, :args=>[0.0]}
+    def set_line_join_style(value)
+        @ruby.printf("    @pdf.set_line_join_style(#{value})\n")
+        end
+
+    #{:name=>:set_line_cap_style, :args=>[1.0]}
+    def set_line_cap_style(value)
+        @ruby.printf("    @pdf.set_line_cap_style(#{value})\n")
+        end
+
+    #{:name=>:set_line_dash, :args=>[[], 0.0]}
+    def set_line_dash(values,widths)
+        @ruby.printf("    @pdf.set_line_dash(#{values.inspect},#{widths})\n")
+        end
+
+    #{:name=>:close_subpath, :args=>[]}
+    def close_subpath()
+	@ruby.printf("    @pdf.close_subpath()\n")
+        end        
+    
+    #{:name=>:stroke_path, :args=>[]}
+    def stroke_path()
+        @ruby.printf("    @pdf.stroke_path()\n")
+        end
+
+    def begin_marked_content(value)
+        @ruby.printf("    @pdf.begin_marked_content(\"#{value}\")\n")
+        end
+
+
+    def end_marked_content()
+        @ruby.printf("    @pdf.end_marked_content()\n")
+        end
+
+    def begin_text_object()
+        @ruby.printf("    @pdf.begin_text_object()\n")
+        end
+
+    def end_text_object()
+        @ruby.printf("    @pdf.end_text_object()\n")
+        end
+
+    def set_character_spacing(space_value)
+        @ruby.printf("    @pdf.set_character_spacing(#{space_value})\n")
+        end
+
+    def move_text_position(x,y)
+        if x
+           @text_position_x = x
+           end
+        if y
+           @text_position_y = y
+           end
+        end
+     
+    def set_text_font_and_size(thefont,thesize)
+        @ruby.printf("    @pdf.set_text_font_and_size(\"%s\", %.3f)\n", thefont, thesize)
+        end
+
+    def set_character_spacing(value)
+        @ruby.printf("    @pdf.set_character_spacing(#{value})\n",value)
+        end
+
+    def set_word_spacing(value)
+        @ruby.printf("    @pdf.set_word_spacing(#{value})\n",value)
+        end
+
+    # there's a few text callbacks, so make sure we process them all
+    def show_text(string)
+      #string = string.chomp.rstrip
+      #if string.empty?
+      #   return
+      #   end
+      string = string.chomp
+      @ruby.printf("    @pdf.show_text(\"#{string}\")\n")
+      end
+
+    def super_show_text(string, *params)
+      string.chomp!
+      if string.empty?
+         return
+         end
+      @ruby.printf("    @pdf.show_text \"%s\"\n", string)
+    end
+
+    def move_to_next_line_and_show_text (string)
+      string.chomp!
+      if string.empty?
+         return
+         end
+      @ruby.printf("    @pdf.add_text %f, %f, \"%s\"\n",
+                   @text_position_x, @text_position_y, string)
+      end
+
+    def set_spacing_next_line_show_text (aw, ac, string)
+      string.chomp!
+      if string.empty?
+         return
+         end
+      @ruby.printf("    @pdf.add_text %f, %f, \"%s\"\n",
+                   @text_position_x, @text_position_y, string)
+      end
+
+    def set_text_matrix_and_text_line_matrix (a,b,c,d,e,f)
+      @text_position_x = f 
+      @text_position_y = e
+      @ruby.printf("    @pdf.set_text_matrix_and_text_line_matrix(%f,%f,%f,%f,%f,%f)\n",
+                        a,b,c,d,e,f)
+      end
+
+    def append_rectangle(a,b,c,d)
+        @ruby.printf("    @pdf.append_rectangle(#{a},#{b},#{c},#{d})\n")
+        end
+
+    def fill_path_with_nonzero()
+        @ruby.printf("    @pdf.fill_path_with_nonzero()\n")
+        end
+
+    def begin_new_subpath(a,b)
+        @ruby.printf("    @pdf.begin_new_subpath(#{a},#{b})\n")
+        end
+
+    def append_line(a,b)
+        @ruby.printf("    @pdf.append_line(#{a},#{b})\n")
+        end
+
+    def end_document()
+        @ruby.printf("    end\n")
+        @ruby.printf("end\n")
+        @ruby.printf("\n\n#Class Test\n")
+        @ruby.printf("doc = %s.new\n",@rubyclass)
+        @ruby.printf("doc.createpage\n")
+        @ruby.printf("doc.rendertofile(\"%s_test.pdf\")\n",@rubyclass)
+        @ruby.close
+        end
+
+    def save_graphics_state()
+        @ruby.printf("    @pdf.save_graphics_state()\n")
+        end
+
+    def restore_graphics_state()
+        @ruby.printf("    @pdf.restore_graphics_state()\n")
+        end
+
+    def concatenate_matrix(a,b,c,d,e,f)
+        @ruby.printf("    @pdf.concatenate_matrix(#{a},#{b},#{c},#{d},#{e},#{f})\n")
+        end
+
+    def resource_xobject(name,image_data)
+        specs = image_data.hash
+        colorspace = specs[:ColorSpace]
+        colorspacetype = colorspace[0]
+        if colorspacetype.to_s == "Indexed"
+           cdata = String.new(colorspace[3])
+           end
+        filename = String.new(name.to_s)
+        width = specs[:Width]
+        height = specs[:Height]
+        external_image(filename,image_data,width,height,cdata)
+        end
+
+    def resource_colorspace(name,val)
+       return
+       type = val[0]
+       specs = val[1]
+       csdef = specs[0]
+       #pp "csdef= ", csdef
+       length = csdef["Length"]
+       data = specs[1]
+       dir_name = @rubyclass.to_s
+       FileUtils.mkdir_p dir_name
+       space_name = dir_name + "/" + name + ".colorspace"
+       raw = File.open(space_name,"wb")
+       raw.write data
+       raw.close
+       end
+        
+    def invoke_xobject(name)
+        @ruby.printf("    @pdf.invoke_xobject(\"#{@rubyclass.to_s}\",\"#{name}\")\n")
+        end
+
+
+
+   def external_image(name,data,width,height,cdata)
+       dir_name = @rubyclass.to_s
+       FileUtils.mkdir_p dir_name
+       pp dir_name
+       raw_name = dir_name + "/" + name + ".raw"
+       cs_name =  dir_name + "/" + name + ".cs"
+       png_name = dir_name + "/" + name + ".png"
+       raw = File.open(cs_name,"w")
+       raw.write cdata
+       raw.close
+       raw = File.open(raw_name,"w")
+       idx = 0
+       data.each_byte do |c|
+            offset = c * 3
+            raw.write(cdata[offset  ].chr)
+            raw.write(cdata[offset+1].chr)
+            raw.write(cdata[offset+2].chr)
+            idx + 1
+            end
+       raw.close
+       #need to convert the RGB file to PNG 
+       canvas = PNG::Canvas.new width, height
+       position = 0
+       for x in (0..height-1)
+         for y in (0..width-1)
+           c = data[position]
+           offset = c * 3
+           canvas[y,x] = PNG::Color.new cdata[offset], cdata[offset+1], cdata[offset+2], 0x00
+           position = position + 1
+           end
+         end
+       png = PNG.new canvas
+       pp png_name
+       png.save png_name
+       end
+
+   def inline_image_raw(data)
+        ccnt = 0
+        @ruby.printf("    image_data = String.new\n")
+        image_data.each_byte do |c| 
+             if ccnt == 0
+                @ruby.printf("    image_data << \"")
+                end
+             @ruby.printf("\\x%2.2x", c)
+             ccnt = ccnt + 1
+             if ccnt == 32 
+                @ruby.printf("\"\n")
+                ccnt = 0
+                end
+             end
+        if ccnt > 0
+           @ruby.printf("\"\n")
+           end
+        @ruby.printf("    @pdf.xobject(id,name,image_specs,image_data)\n")
+       end
+
+  end
+
+pdf_filename = ARGV[0]
+ruby_filename = ARGV[1]
+methodname = ARGV[2]
+
+rubyfile = File.open(ruby_filename, "w")
+
+receiver = PDFReceiver.new
+receiver.initextclass(rubyfile,methodname)
+
+pdf = PDF::Reader.file(pdf_filename, receiver)

data/lib/dumppdf.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'pdf/reader'
+require 'pdf/writer'
+require 'pp'
+
+$KCODE = 'u'
+require 'jcode'
+require 'iconv'
+require 'base64'
+
+
+
+pdf_filename = ARGV[0]
+
+receiver = PDF::Reader::RegisterReceiver.new
+pdf = PDF::Reader.file(pdf_filename, receiver)
+    receiver.callbacks.each do |cb|
+    pp cb
+  end
+
+

data/lib/pdf-extended-ops.rb

@@ -0,0 +1,151 @@
+# Extensions by Glenn S. West 
+# Extra methods to allow a more "direct" mapping" from pdf-reader
+require 'pp'
+
+class PDF::Writer
+    #Hacked add image to not mess up coordinate space - gsw
+    def myimage(image, label)
+
+      if image.respond_to?(:read)
+        data = image.read
+       else
+        open(image, 'rb') { |ff| data = ff.read }
+        end
+
+      image_info ||= PDF::Writer::Graphics::ImageInfo.new(data)
+      tt = Time.now
+      @images << tt
+      id = @images.index(tt)
+      image_obj = PDF::Writer::External::Image.new(self, data, image_info, label)
+      @images[id] = image_obj
+
+      image_obj
+      end
+
+  def save_graphics_state()
+      add_content("\nq")
+      end
+
+  def restore_graphics_state()
+      add_content("\nQ")
+      end
+
+  def concatenate_matrix(a,b,c,d,e,f)
+      add_content("\n%f %f %f %f %f %f cm" % [ a, b, c, d, e, f])
+      @pdfeo_matrix = Array.[](a,b,c,d,e,f)
+      end
+
+  def invoke_xobject(form,name)
+       dir_name = @rubyclass.to_s
+       png_name = form + "/" + name + ".png"
+       myimage(png_name, name)
+       add_content("\n/#{name} Do")
+      end
+
+  # Page 405 - PDF Reference
+  def begin_text_object()
+      add_content("\nBT")
+      end
+
+  def set_character_spacing(value)
+      add_content("\n #{value} Tc")
+      end
+
+  def set_word_spacing(value)
+      add_content("\n #{value} Tw")
+      end
+
+  def set_text_font_and_size(fontabbr,fontsize)
+      add_content("\n/#{fontabbr} #{fontsize} Tf")
+      end
+
+  def end_text_object()
+      add_content("\nET")
+      end
+
+  def show_text(txt)
+      thetxt = txt.gsub('\\','\\\\')
+      thetxt = thetxt.gsub('(','\(')
+      thetxt = thetxt.gsub(')','\)')
+      add_content("\n(#{thetxt})Tj")
+      end
+
+  # set_line_matrix_and_text_line_matrix
+  def set_text_matrix_and_text_line_matrix(a, b, c, d, e, f)
+    add_content("\n%f %f %f %f %f %f Tm" % [ a, b, c, d, e, f ])
+  end
+
+  def begin_marked_content(value)
+      add_content("\n/#{value} BMC")
+      end
+
+  def begin_marked_content_with_p1(flag, mcid_type, mcid_value)
+      add_content("\n/#{flag} << /#{mcid_type} #{mcid_value} >>\nBDC")
+      end
+  
+  #Page 679 - PDF Reference
+  def end_marked_content()
+      add_content("\nEMC")
+      end
+
+  def append_rectangle(a,b,c,d)
+      add_content("\n#{a} #{b} #{c} #{d} re")
+      end
+
+  def fill_path_with_nonzero()
+      add_content("\nf")
+      end
+
+  def begin_new_subpath(a,b)
+      add_content("\n#{a} #{b} m")
+      end
+
+  def append_line(a,b)
+      add_content("\n#{a} #{b} l")
+      end
+
+  #{:name=>:set_gray_for_stroking, :args=>[0.0]}
+  def set_gray_for_stroking(value)
+      add_content("\n#{value} G")
+      end
+
+  #{:name=>:set_line_width, :args=>[0.72]}
+  def set_line_width(value)
+      add_content("\n#{value} w")
+      end
+
+  #{:name=>:set_miter_limit, :args=>[10.0]}
+  def set_miter_limit(value)
+      add_content("\n#{value} M")
+      end
+
+  #{:name=>:set_line_join_style, :args=>[0.0]}
+  def set_line_join_style(value)
+      thevalue = value.to_i
+      add_content("\n#{thevalue} j")
+      end
+
+  #{:name=>:set_line_cap_style, :args=>[1.0]}
+  def set_line_cap_style(value)
+      thevalue = value.to_i
+      add_content("\n#{thevalue} J")
+      end
+
+  #{:name=>:set_line_dash, :args=>[[], 0.0]}
+  def set_line_dash(values,width)
+      hash_values = values.inspect
+      thecontent = "\n#{hash_values} #{width} d"
+      add_content(thecontent)
+      end
+
+  #{:name=>:close_subpath, :args=>[]}
+  def close_subpath()
+      add_content("\n h")
+      end        
+    
+  #{:name=>:stroke_path, :args=>[]}
+  def stroke_path()
+      add_content("\n S")
+      end
+
+end

data/lib/pdftoruby.rb

@@ -0,0 +1,3 @@
+class Pdftoruby
+  VERSION = '0.0.4'
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: pdftoruby
+version: !ruby/object:Gem::Version 
+  version: 0.0.4
+platform: ruby
+authors: 
+- glennswest
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-05-20 00:00:00 +08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.5.1
+    version: 
+description: Convert pdf files into ruby classes - allow creation of complex pdf files from existing pdf files
+email: 
+- glennswest@yahoo.com.sg
+executables: 
+- pdftoruby.rb
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/pdftoruby.rb
+- lib/dumppdf.rb
+- lib/pdf-extended-ops.rb
+- lib/pdftoruby.rb
+has_rdoc: true
+homepage: http://code.google.com/p/pdftoruby/
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: pdftoruby
+rubygems_version: 1.1.1
+signing_key: 
+specification_version: 2
+summary: Convert pdf files into ruby classes - allow creation of complex pdf files from existing pdf files
+test_files: []
+