combine_pdf 0.1.23 → 0.2.0

data/lib/combine_pdf/renderer.rb

@@ -0,0 +1,168 @@
+module CombinePDF
+
+	################################################################
+	## These are common functions, used within the different classes
+	## These functions aren't open to the public.
+	################################################################
+
+
+	# This is an internal module used to render ruby objects into pdf objects.
+	module Renderer
+
+		# @!visibility private
+
+		protected
+
+
+		# Formats an object into PDF format. This is used my the PDF object to format the PDF file and it is used in the secure injection which is still being developed.
+		def object_to_pdf object
+			case
+			when object.nil?
+				return "null"
+			when object.is_a?(String)
+				return format_string_to_pdf object
+			when object.is_a?(Symbol)
+				return format_name_to_pdf object
+			when object.is_a?(Array)
+				return format_array_to_pdf object
+			when object.is_a?(Fixnum), object.is_a?(Float), object.is_a?(TrueClass), object.is_a?(FalseClass)
+				return object.to_s + " "
+			when object.is_a?(Hash)
+				return format_hash_to_pdf object
+			else
+				return ''
+			end
+		end
+
+		def format_string_to_pdf(object)
+			object.force_encoding(Encoding::ASCII_8BIT)
+			if !object.force_encoding(Encoding::ASCII_8BIT).match(/[^D\:\d\+\-\Z\']/) #if format is set to Literal
+				#### can be better...
+				replacement_hash = {
+					"\x0A" => "\\n",
+					"\x0D" => "\\r",
+					"\x09" => "\\t",
+					"\x08" => "\\b",
+					"\xFF" => "\\f",
+					"\x28" => "\\(",
+					"\x29" => "\\)",
+					"\x5C" => "\\\\"
+				}
+				32.times {|i| replacement_hash[i.chr] ||= "\\#{i}"}
+				(256-128).times {|i| replacement_hash[(i + 127).chr] ||= "\\#{i+127}"}
+				("(" + ([].tap {|out| object.bytes.each {|byte| replacement_hash[ byte.chr ] ? (replacement_hash[ byte.chr ].bytes.each {|b| out << b}) : out << byte } }).pack('C*') + ")").force_encoding(Encoding::ASCII_8BIT)
+			else
+				# A hexadecimal string shall be written as a sequence of hexadecimal digits (0–9 and either A–F or a–f)
+				# encoded as ASCII characters and enclosed within angle brackets (using LESS-THAN SIGN (3Ch) and GREATER- THAN SIGN (3Eh)). 
+				("<" + object.unpack('H*')[0] + ">").force_encoding(Encoding::ASCII_8BIT)
+			end
+		end
+		def format_name_to_pdf(object)
+			# a name object is an atomic symbol uniquely defined by a sequence of ANY characters (8-bit values) except null (character code 0).
+			# print name as a simple string. all characters between ~ and ! (except #) can be raw
+			# the rest will have a number sign and their HEX equivalant
+			# from the standard:
+			# When writing a name in a PDF file, a SOLIDUS (2Fh) (/) shall be used to introduce a name. The SOLIDUS is not part of the name but is a prefix indicating that what follows is a sequence of characters representing the name in the PDF file and shall follow these rules:
+			# a) A NUMBER SIGN (23h) (#) in a name shall be written by using its 2-digit hexadecimal code (23), preceded by the NUMBER SIGN.
+			# b) Any character in a name that is a regular character (other than NUMBER SIGN) shall be written as itself or by using its 2-digit hexadecimal code, preceded by the NUMBER SIGN.
+			# c) Any character that is not a regular character shall be written using its 2-digit hexadecimal code, preceded by the NUMBER SIGN only.
+			# [0x00, 0x09, 0x0a, 0x0c, 0x0d, 0x20, 0x28, 0x29, 0x3c, 0x3e, 0x5b, 0x5d, 0x7b, 0x7d, 0x2f, 0x25]
+			out = object.to_s.bytes.to_a.map do |b|
+				case b
+				when 0..15
+					'#0' + b.to_s(16)
+				when 15..32, 35, 37, 40, 41, 47, 60, 62, 91, 93, 123, 125, 127..256
+					'#' + b.to_s(16)
+				else
+					b.chr
+				end
+			end
+			"/" + out.join()
+		end
+		def format_array_to_pdf(object)
+			# An array shall be written as a sequence of objects enclosed in SQUARE BRACKETS (using LEFT SQUARE BRACKET (5Bh) and RIGHT SQUARE BRACKET (5Dh)).
+			# EXAMPLE [549 3.14 false (Ralph) /SomeName]
+			("[" + (object.collect {|item| object_to_pdf(item)}).join(' ') + "]").force_encoding(Encoding::ASCII_8BIT)
+			
+		end
+
+		def format_hash_to_pdf(object)
+			# if the object is only a reference:
+			# special conditions apply, and there is only the setting of the reference (if needed) and output
+			if object[:is_reference_only]
+				#
+				if object[:referenced_object] && object[:referenced_object].is_a?(Hash)
+					object[:indirect_reference_id] = object[:referenced_object][:indirect_reference_id]
+					object[:indirect_generation_number] = object[:referenced_object][:indirect_generation_number]
+				end
+				object[:indirect_reference_id] ||= 0
+				object[:indirect_generation_number] ||= 0
+				return "#{object[:indirect_reference_id].to_s} #{object[:indirect_generation_number].to_s} R".force_encoding(Encoding::ASCII_8BIT)
+			end
+
+			# if the object is indirect...
+			out = []
+			if object[:indirect_reference_id]
+				object[:indirect_reference_id] ||= 0
+				object[:indirect_generation_number] ||= 0
+				out << "#{object[:indirect_reference_id].to_s} #{object[:indirect_generation_number].to_s} obj\n".force_encoding(Encoding::ASCII_8BIT)
+				if object[:indirect_without_dictionary]
+					out << object_to_pdf(object[:indirect_without_dictionary])
+					out << "\nendobj\n"
+					return out.join().force_encoding(Encoding::ASCII_8BIT)
+				end
+			end
+			# correct stream length, if the object is a stream.
+			object[:Length] = object[:raw_stream_content].bytesize if object[:raw_stream_content]
+
+			# if the object is not a simple object, it is a dictionary
+			# A dictionary shall be written as a sequence of key-value pairs enclosed in double angle brackets (<<...>>)
+			# (using LESS-THAN SIGNs (3Ch) and GREATER-THAN SIGNs (3Eh)).
+			out << "<<\n".force_encoding(Encoding::ASCII_8BIT)
+			object.each do |key, value|
+				out << "#{object_to_pdf key} #{object_to_pdf value}\n".force_encoding(Encoding::ASCII_8BIT) unless PDF::PRIVATE_HASH_KEYS.include? key
+			end
+			out << ">>".force_encoding(Encoding::ASCII_8BIT)
+			out << "\nstream\n#{object[:raw_stream_content]}\nendstream".force_encoding(Encoding::ASCII_8BIT) if object[:raw_stream_content]
+			out << "\nendobj\n" if object[:indirect_reference_id]
+			out.join().force_encoding(Encoding::ASCII_8BIT)
+		end
+
+		def actual_object obj
+			obj.is_a?(Hash) ? (obj[:referenced_object] || obj) : obj
+		end
+
+		# Ruby normally assigns pointes.
+		# noramlly:
+		#   a = [1,2,3] # => [1,2,3]
+		#   b = a # => [1,2,3]
+		#   a << 4 # => [1,2,3,4]
+		#   b # => [1,2,3,4]
+		# This method makes sure that the memory is copied instead of a pointer assigned.
+		# this works using recursion, so that arrays and hashes within arrays and hashes are also copied and not pointed to.
+		# One needs to be careful of infinit loops using this function.
+		def create_deep_copy object
+			if object.is_a?(Array)
+				return object.map { |e|  create_deep_copy e  }
+			elsif object.is_a?(Hash)
+				return {}.tap {|out|  object.each {|k,v| out[create_deep_copy(k)] = create_deep_copy(v) unless k == :Parent} }
+			elsif object.is_a?(String)
+				return object.dup
+			else
+				return object # objects that aren't Strings, Arrays or Hashes (such as Symbols and Fixnums) won't be edited inplace.
+			end
+		end
+	end
+end
+
+#########################################################
+# this file is part of the CombinePDF library and the code
+# is subject to the same license (MIT).
+#########################################################
+# PDF object types cross reference:
+# Indirect objects, references, dictionaries and streams are Hash
+# arrays are Array
+# strings are String
+# names are Symbols (String.to_sym)
+# numbers are Fixnum or Float
+# boolean are TrueClass or FalseClass

data/lib/combine_pdf/version.rb

@@ -1,3 +1,3 @@
 module CombinePDF
-  VERSION = "0.1.23"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: combine_pdf
 version: !ruby/object:Gem::Version
-  version: 0.1.23
+  version: 0.2.0
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-28 00:00:00.000000000 Z
+date: 2015-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-rc4
@@ -53,8 +53,8 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '10.0'
 description: A nifty gem, in pure Ruby, to parse PDF files and combine (merge) them
-  with other PDF files, number the pages, watermark them or stamp them, create tables
-  or basic text objects etc` (all using the PDF file format).
+  with other PDF files, number the pages, watermark them or stamp them, create tables,
+  add basic text objects etc` (all using the PDF file format).
 email:
 - boaz@2be.co.il
 executables: []
@@ -69,15 +69,17 @@ files:
 - Rakefile
 - combine_pdf.gemspec
 - lib/combine_pdf.rb
-- lib/combine_pdf/combine_pdf_basic_writer.rb
-- lib/combine_pdf/combine_pdf_decrypt.rb
-- lib/combine_pdf/combine_pdf_filter.rb
-- lib/combine_pdf/combine_pdf_fonts.rb
-- lib/combine_pdf/combine_pdf_methods.rb
-- lib/combine_pdf/combine_pdf_operations.rb
-- lib/combine_pdf/combine_pdf_page.rb
-- lib/combine_pdf/combine_pdf_parser.rb
-- lib/combine_pdf/combine_pdf_pdf.rb
+- lib/combine_pdf/api.rb
+- lib/combine_pdf/basic_writer.rb
+- lib/combine_pdf/decrypt.rb
+- lib/combine_pdf/filter.rb
+- lib/combine_pdf/fonts.rb
+- lib/combine_pdf/operations.rb
+- lib/combine_pdf/page_methods.rb
+- lib/combine_pdf/parser.rb
+- lib/combine_pdf/pdf_protected.rb
+- lib/combine_pdf/pdf_public.rb
+- lib/combine_pdf/renderer.rb
 - lib/combine_pdf/version.rb
 homepage: https://github.com/boazsegev/combine_pdf
 licenses:

data/lib/combine_pdf/combine_pdf_basic_writer.rb

@@ -1,451 +0,0 @@
-# -*- encoding : utf-8 -*-
-########################################################
-## Thoughts from reading the ISO 32000-1:2008
-## this file is part of the CombinePDF library and the code
-## is subject to the same license.
-########################################################
-
-
-
-
-module CombinePDF
-
-	# Limited Unicode Support (font dependent)!
-	#
-	# The PDFWriter class is a subclass of Hash and represents a PDF Page object.
-	#
-	# Writing on this Page is done using the textbox function.
-	#
-	# Setting the page dimensions can be either at the new or using the mediabox method. New pages default to size A4, which is: [0, 0, 595.3, 841.9].
-	#
-	# Once the Page is completed (the last text box was added),
-	# we can insert the page to a CombinePDF object.
-	#
-	# We can either insert the PDFWriter as a new page:
-	#   pdf = CombinePDF.new
-	#   new_page = PDFWriter.new
-	#   new_page.textbox "some text"
-	#   pdf << new_page
-	#   pdf.save "file_with_new_page.pdf"
-	# Or we can insert the PDFWriter as an overlay (stamp / watermark) over existing pages:
-	#   pdf = CombinePDF.new
-	#   new_page = PDFWriter.new "some_file.pdf"
-	#   new_page.textbox "some text"
-	#   pdf.pages.each {|page| page << new_page }
-	#   pdf.save "stamped_file.pdf"
-	class PDFWriter < Hash
-
-		# create a new PDFWriter object.
-		#
-		# mediabox:: the PDF page size in PDF points. defaults to [0, 0, 595.3, 841.9] (A4)
-		def initialize(mediabox = [0, 0, 595.3, 841.9])
-			# indirect_reference_id, :indirect_generation_number
-			@contents = ""
-			@base_font_name = "Writer" + SecureRandom.hex(7) + "PDF"
-			self[:Type] = :Page
-			self[:indirect_reference_id] = 0
-			self[:Resources] = {}
-			self[:Contents] = { is_reference_only: true , referenced_object: {indirect_reference_id: 0, raw_stream_content: @contents} }
-			self[:MediaBox] = mediabox
-		end
-
-		# includes the PDF Page_Methods module, including all page methods (textbox etc').
-		include Page_Methods
-
-		# # accessor (getter) for the :MediaBox element of the page
-		# def mediabox
-		# 	self[:MediaBox]
-		# end
-		# # accessor (setter) for the :MediaBox element of the page
-		# # dimensions:: an Array consisting of four numbers (can be floats) setting the size of the media box.
-		# def mediabox=(dimensions = [0.0, 0.0, 612.0, 792.0])
-		# 	self[:MediaBox] = dimensions
-		# end
-
-		# # This method adds a simple text box to the Page represented by the PDFWriter class.
-		# # This function takes two values:
-		# # text:: the text to potin the box.
-		# # properties:: a Hash of box properties.
-		# # the symbols and values in the properties Hash could be any or all of the following:
-		# # x:: the left position of the box.
-		# # y:: the BUTTOM position of the box.
-		# # width:: the width/length of the box. negative values will be computed from edge of page. defaults to 0 (end of page).
-		# # height:: the height of the box. negative values will be computed from edge of page. defaults to 0 (end of page).
-		# # text_align:: symbol for horizontal text alignment, can be ":center" (default), ":right", ":left"
-		# # text_valign:: symbol for vertical text alignment, can be ":center" (default), ":top", ":buttom"
-		# # text_padding:: a Float between 0 and 1, setting the padding for the text. defaults to 0.05 (5%).
-		# # font:: a registered font name or an Array of names. defaults to ":Helvetica". The 14 standard fonts names are:
-		# # - :"Times-Roman"
-		# # - :"Times-Bold"
-		# # - :"Times-Italic"
-		# # - :"Times-BoldItalic"
-		# # - :Helvetica
-		# # - :"Helvetica-Bold"
-		# # - :"Helvetica-BoldOblique"
-		# # - :"Helvetica- Oblique"
-		# # - :Courier
-		# # - :"Courier-Bold"
-		# # - :"Courier-Oblique"
-		# # - :"Courier-BoldOblique"
-		# # - :Symbol
-		# # - :ZapfDingbats
-		# # font_size:: a Fixnum for the font size, or :fit_text to fit the text in the box. defaults to ":fit_text"
-		# # max_font_size:: if font_size is set to :fit_text, this will be the maximum font size. defaults to nil (no maximum)
-		# # font_color:: text color in [R, G, B], an array with three floats, each in a value between 0 to 1 (gray will be "[0.5, 0.5, 0.5]"). defaults to black.
-		# # stroke_color:: text stroke color in [R, G, B], an array with three floats, each in a value between 0 to 1 (gray will be "[0.5, 0.5, 0.5]"). defounlts to nil (no stroke).
-		# # stroke_width:: text stroke width in PDF units. defaults to 0 (none).
-		# # box_color:: box fill color in [R, G, B], an array with three floats, each in a value between 0 to 1 (gray will be "[0.5, 0.5, 0.5]"). defaults to nil (none).
-		# # border_color:: box border color in [R, G, B], an array with three floats, each in a value between 0 to 1 (gray will be "[0.5, 0.5, 0.5]"). defaults to nil (none).
-		# # border_width:: border width in PDF units. defaults to nil (none).
-		# # box_radius:: border radius in PDF units. defaults to 0 (no corner rounding).
-		# # opacity:: textbox opacity, a float between 0 (transparent) and 1 (opaque)
-		# def textbox(text, properties = {})
-		# 	options = {
-		# 		x: 0,
-		# 		y: 0,
-		# 		width: 0,
-		# 		height: -1,
-		# 		text_align: :center,
-		# 		text_valign: :center,
-		# 		text_padding: 0.1,
-		# 		font: nil,
-		# 		font_size: :fit_text,
-		# 		max_font_size: nil,
-		# 		font_color: [0,0,0],
-		# 		stroke_color: nil,
-		# 		stroke_width: 0,
-		# 		box_color: nil,
-		# 		border_color: nil,
-		# 		border_width: 0,
-		# 		box_radius: 0,
-		# 		opacity: 1,
-		# 		ctm: [1,0,0,1,0,0]
-		# 	}
-		# 	options.update properties
-		# 	# reset the length and height to meaningful values, if negative
-		# 	options[:width] = mediabox[2] - options[:x] + options[:width] if options[:width] <= 0
-		# 	options[:height] = mediabox[3] - options[:y] + options[:height] if options[:height] <= 0
-
-		# 	# reset the padding value
-		# 	options[:text_padding] = 0 if options[:text_padding].to_f >= 1
-
-		# 	# create box stream
-		# 	box_stream = ""
-		# 	# set graphic state for box
-		# 	if options[:box_color] || (options[:border_width].to_i > 0 && options[:border_color])
-		# 		# compute x and y position for text
-		# 		x = options[:x]
-		# 		y = options[:y]
-
-		# 		# set graphic state for the box
-		# 		box_stream << "q\n"
-		# 		box_graphic_state = { ca: options[:opacity], CA: options[:opacity], LW: options[:border_width], LC: 0, LJ: 0,  LD: 0, CTM: options[:ctm]}
-		# 		if options[:box_radius] != 0 # if the text box has rounded corners
-		# 			box_graphic_state[:LC], box_graphic_state[:LJ] =  2, 1
-		# 		end
-		# 		box_graphic_state = graphic_state box_graphic_state # adds the graphic state to Resources and gets the reference
-		# 		box_stream << "#{PDFOperations._object_to_pdf box_graphic_state} gs\n"
-
-		# 		# the following line was removed for Acrobat Reader compatability
-		# 		# box_stream << "DeviceRGB CS\nDeviceRGB cs\n"
-
-		# 		if options[:box_color]
-		# 			box_stream << "#{options[:box_color].join(' ')} rg\n"
-		# 		end
-		# 		if options[:border_width].to_i > 0 && options[:border_color]
-		# 			box_stream << "#{options[:border_color].join(' ')} RG\n"
-		# 		end
-		# 		# create the path
-		# 		radius = options[:box_radius]
-		# 		half_radius = (radius.to_f / 2).round 4
-		# 		## set starting point
-		# 		box_stream << "#{options[:x] + radius} #{options[:y]} m\n" 
-		# 		## buttom and right corner - first line and first corner
-		# 		box_stream << "#{options[:x] + options[:width] - radius} #{options[:y]} l\n" #buttom
-		# 		if options[:box_radius] != 0 # make first corner, if not straight.
-		# 			box_stream << "#{options[:x] + options[:width] - half_radius} #{options[:y]} "
-		# 			box_stream << "#{options[:x] + options[:width]} #{options[:y] + half_radius} "
-		# 			box_stream << "#{options[:x] + options[:width]} #{options[:y] + radius} c\n"
-		# 		end
-		# 		## right and top-right corner
-		# 		box_stream << "#{options[:x] + options[:width]} #{options[:y] + options[:height] - radius} l\n"
-		# 		if options[:box_radius] != 0
-		# 			box_stream << "#{options[:x] + options[:width]} #{options[:y] + options[:height] - half_radius} "
-		# 			box_stream << "#{options[:x] + options[:width] - half_radius} #{options[:y] + options[:height]} "
-		# 			box_stream << "#{options[:x] + options[:width] - radius} #{options[:y] + options[:height]} c\n"
-		# 		end
-		# 		## top and top-left corner
-		# 		box_stream << "#{options[:x] + radius} #{options[:y] + options[:height]} l\n"
-		# 		if options[:box_radius] != 0
-		# 			box_stream << "#{options[:x] + half_radius} #{options[:y] + options[:height]} "
-		# 			box_stream << "#{options[:x]} #{options[:y] + options[:height] - half_radius} "
-		# 			box_stream << "#{options[:x]} #{options[:y] + options[:height] - radius} c\n"
-		# 		end
-		# 		## left and buttom-left corner
-		# 		box_stream << "#{options[:x]} #{options[:y] + radius} l\n"
-		# 		if options[:box_radius] != 0
-		# 			box_stream << "#{options[:x]} #{options[:y] + half_radius} "
-		# 			box_stream << "#{options[:x] + half_radius} #{options[:y]} "
-		# 			box_stream << "#{options[:x] + radius} #{options[:y]} c\n"
-		# 		end
-		# 		# fill / stroke path
-		# 		box_stream << "h\n"
-		# 		if options[:box_color] && options[:border_width].to_i > 0 && options[:border_color]
-		# 			box_stream << "B\n"
-		# 		elsif options[:box_color] # fill if fill color is set
-		# 			box_stream << "f\n"
-		# 		elsif options[:border_width].to_i > 0 && options[:border_color] # stroke if border is set
-		# 			box_stream << "S\n"
-		# 		end
-
-		# 		# exit graphic state for the box
-		# 		box_stream << "Q\n"
-		# 	end
-		# 	contents << box_stream
-
-		# 	# reset x,y by text alignment - x,y are calculated from the buttom left
-		# 	# each unit (1) is 1/72 Inch
-		# 	# create text stream
-		# 	text_stream = ""
-		# 	if text.to_s != "" && options[:font_size] != 0 && (options[:font_color] || options[:stroke_color])
-		# 		# compute x and y position for text
-		# 		x = options[:x] + (options[:width]*options[:text_padding])
-		# 		y = options[:y] + (options[:height]*options[:text_padding])
-
-		# 		# set the fonts (fonts array, with :Helvetica as fallback).
-		# 		fonts = [*options[:font], :Helvetica]
-		# 		# fit text in box, if requested
-		# 		font_size = options[:font_size]
-		# 		if options[:font_size] == :fit_text
-		# 			font_size = self.fit_text text, fonts, (options[:width]*(1-options[:text_padding])), (options[:height]*(1-options[:text_padding]))
-		# 			font_size = options[:max_font_size] if options[:max_font_size] && font_size > options[:max_font_size]
-		# 		end
-
-		# 		text_size = dimensions_of text, fonts, font_size
-
-		# 		if options[:text_align] == :center
-		# 			x = ( ( options[:width]*(1-(2*options[:text_padding])) ) - text_size[0] )/2 + x
-		# 		elsif options[:text_align] == :right
-		# 			x = ( ( options[:width]*(1-(1.5*options[:text_padding])) ) - text_size[0] ) + x
-		# 		end
-		# 		if options[:text_valign] == :center
-		# 			y = ( ( options[:height]*(1-(2*options[:text_padding])) ) - text_size[1] )/2 + y
-		# 		elsif options[:text_valign] == :top
-		# 			y = ( options[:height]*(1-(1.5*options[:text_padding])) ) - text_size[1] + y
-		# 		end
-
-		# 		# set graphic state for text
-		# 		text_stream << "q\n"
-		# 		text_graphic_state = graphic_state({ca: options[:opacity], CA: options[:opacity], LW: options[:stroke_width].to_f, LC: 2, LJ: 1,  LD: 0, CTM: options[:ctm]})
-		# 		text_stream << "#{PDFOperations._object_to_pdf text_graphic_state} gs\n"
-
-		# 		# the following line was removed for Acrobat Reader compatability
-		# 		# text_stream << "DeviceRGB CS\nDeviceRGB cs\n"
-
-		# 		# set text render mode
-		# 		if options[:font_color]
-		# 			text_stream << "#{options[:font_color].join(' ')} rg\n"
-		# 		end
-		# 		if options[:stroke_width].to_i > 0 && options[:stroke_color]
-		# 			text_stream << "#{options[:stroke_color].join(' ')} RG\n"
-		# 			if options[:font_color]
-		# 				text_stream << "2 Tr\n"
-		# 			else
-		# 				final_stream << "1 Tr\n"
-		# 			end
-		# 		elsif options[:font_color]
-		# 			text_stream << "0 Tr\n"
-		# 		else
-		# 			text_stream << "3 Tr\n"
-		# 		end
-		# 		# format text object(s)
-		# 			# text_stream << "#{options[:font_color].join(' ')} rg\n" # sets the color state
-		# 		encode(text, fonts).each do |encoded|
-		# 			text_stream << "BT\n" # the Begine Text marker			
-		# 			text_stream << PDFOperations._format_name_to_pdf(set_font encoded[0]) # Set font name
-		# 			text_stream << " #{font_size.round 3} Tf\n" # set font size and add font operator
-		# 			text_stream << "#{x.round 4} #{y.round 4} Td\n" # set location for text object
-		# 			text_stream << (  encoded[1] ) # insert the encoded string to the stream
-		# 			text_stream << " Tj\n" # the Text object operator and the End Text marker
-		# 			text_stream << "ET\n" # the Text object operator and the End Text marker
-		# 			x += encoded[2]/1000*font_size #update text starting point
-		# 			y -= encoded[3]/1000*font_size #update text starting point
-		# 		end
-		# 		# exit graphic state for text
-		# 		text_stream << "Q\n"
-		# 	end
-		# 	contents << text_stream
-
-		# 	self
-		# end
-		# # gets the dimentions (width and height) of the text, as it will be printed in the PDF.
-		# #
-		# # text:: the text to measure
-		# # font:: a font name or an Array of font names. Font names should be registered fonts. The 14 standard fonts are pre regitered with the font library.
-		# # size:: the size of the font (defaults to 1000 points).
-		# def dimensions_of(text, fonts, size = 1000)
-		# 	Fonts.dimensions_of text, fonts, size
-		# end
-		# # this method returns the size for which the text fits the requested metrices
-		# # the size is type Float and is rather exact
-		# # if the text cannot fit such a small place, returns zero (0).
-		# # maximum font size possible is set to 100,000 - which should be big enough for anything
-		# # text:: the text to fit
-		# # font:: the font name. @see font
-		# # length:: the length to fit
-		# # height:: the height to fit (optional - normally length is the issue)
-		# def fit_text(text, font, length, height = 10000000)
-		# 	size = 100000
-		# 	size_array = [size]
-		# 	metrics = Fonts.dimensions_of text, font, size
-		# 	if metrics[0] > length
-		# 		size_array << size * length/metrics[0]
-		# 	end
-		# 	if metrics[1] > height
-		# 		size_array << size * height/metrics[1]
-		# 	end
-		# 	size_array.min
-		# end
-
-
-		# protected
-
-		# # accessor (getter) for the :Resources element of the page
-		# def resources
-		# 	self[:Resources]
-		# end
-		# # accessor (getter) for the stream in the :Contents element of the page
-		# # after getting the string object, you can operate on it but not replace it (use << or other String methods).
-		# def contents
-		# 	@contents
-		# end
-		# # creates a font object and adds the font to the resources dictionary
-		# # returns the name of the font for the content stream.
-		# # font:: a Symbol of one of the fonts registered in the library, or:
-		# # - :"Times-Roman"
-		# # - :"Times-Bold"
-		# # - :"Times-Italic"
-		# # - :"Times-BoldItalic"
-		# # - :Helvetica
-		# # - :"Helvetica-Bold"
-		# # - :"Helvetica-BoldOblique"
-		# # - :"Helvetica- Oblique"
-		# # - :Courier
-		# # - :"Courier-Bold"
-		# # - :"Courier-Oblique"
-		# # - :"Courier-BoldOblique"
-		# # - :Symbol
-		# # - :ZapfDingbats
-		# def set_font(font = :Helvetica)
-		# 	# if the font exists, return it's name
-		# 	resources[:Font] ||= {}
-		# 	resources[:Font].each do |k,v|
-		# 		if v.is_a?(Fonts::Font) && v.name && v.name == font
-		# 			return k
-		# 		end
-		# 	end
-		# 	# set a secure name for the font
-		# 	name = (@base_font_name + (resources[:Font].length + 1).to_s).to_sym
-		# 	# get font object
-		# 	font_object = Fonts.get_font(font)
-		# 	# return false if the font wan't found in the library.
-		# 	return false unless font_object
-		# 	# add object to reasource
-		# 	resources[:Font][name] = font_object
-		# 	#return name
-		# 	name
-		# end
-		# # register or get a registered graphic state dictionary.
-		# # the method returns the name of the graphos state, for use in a content stream.
-		# def graphic_state(graphic_state_dictionary = {})
-		# 	# if the graphic state exists, return it's name
-		# 	resources[:ExtGState] ||= {}
-		# 	resources[:ExtGState].each do |k,v|
-		# 		if v.is_a?(Hash) && v == graphic_state_dictionary
-		# 			return k
-		# 		end
-		# 	end
-		# 	# set graphic state type
-		# 	graphic_state_dictionary[:Type] = :ExtGState
-		# 	# set a secure name for the graphic state
-		# 	name = (SecureRandom.hex(9)).to_sym
-		# 	# add object to reasource
-		# 	resources[:ExtGState][name] = graphic_state_dictionary
-		# 	#return name
-		# 	name
-		# end
-
-		# # encodes the text in an array of [:font_name, <PDFHexString>] for use in textbox
-		# def encode text, fonts
-		# 	# text must be a unicode string and fonts must be an array.
-		# 	# this is an internal method, don't perform tests.
-		# 	fonts_array = []
-		# 	fonts.each do |name|
-		# 		f = Fonts.get_font name
-		# 		fonts_array << f if f
-		# 	end
-
-		# 	# before starting, we should reorder any RTL content in the string
-		# 	text = reorder_rtl_content text
-
-		# 	out = []
-		# 	text.chars.each do |c|
-		# 		fonts_array.each_index do |i|
-		# 			if fonts_array[i].cmap.nil? || (fonts_array[i].cmap && fonts_array[i].cmap[c])
-		# 				#add to array
-		# 				if out.last.nil? || out.last[0] != fonts[i]
-		# 					out.last[1] << ">" unless out.last.nil?
-		# 					out << [fonts[i], "<" , 0, 0] 
-		# 				end
-		# 				out.last[1] << ( fonts_array[i].cmap.nil? ? ( c.unpack("H*")[0] ) : (fonts_array[i].cmap[c]) )
-		# 				if fonts_array[i].metrics[c]
-		# 					out.last[2] += fonts_array[i].metrics[c][:wx].to_f
-		# 					out.last[3] += fonts_array[i].metrics[c][:wy].to_f
-		# 				end
-		# 				break
-		# 			end
-		# 		end
-		# 	end
-		# 	out.last[1] << ">" if out.last
-		# 	out
-		# end
-
-		# # a very primitive text reordering algorithm... I was lazy...
-		# # ...still, it works (I think).
-		# def reorder_rtl_content text
-		# 	rtl_characters = "\u05d0-\u05ea\u05f0-\u05f4\u0600-\u06ff\u0750-\u077f"
-		# 	rtl_replaces = { '(' => ')', ')' => '(',
-		# 					'[' => ']', ']'=>'[',
-		# 					'{' => '}', '}'=>'{',
-		# 					'<' => '>', '>'=>'<',
-		# 					}
-		# 	return text unless text =~ /[#{rtl_characters}]/
-
-		# 	out = []
-		# 	scanner = StringScanner.new text
-		# 	until scanner.eos? do
-		# 		if scanner.scan /[#{rtl_characters} ]/
-		# 			out.unshift scanner.matched
-		# 		elsif scanner.scan /[^#{rtl_characters}]+/
-		# 			if out.empty? && scanner.matched.match(/[\s]$/) && !scanner.eos?
-		# 				white_space_to_move = scanner.matched.match(/[\s]+$/).to_s
-		# 				out.unshift scanner.matched[0..-1-white_space_to_move.length]
-		# 				out.unshift white_space_to_move
-		# 			elsif scanner.matched.match /^[\(\)\[\]\{\}\<\>]$/
-		# 				out.unshift rtl_replaces[scanner.matched]
-		# 			else
-		# 				out.unshift scanner.matched
-		# 			end
-		# 		end
-		# 	end
-		# 	out.join.strip
-		# end
-
-	end
-	
-end
-
-
-
-
-