combine_pdf 0.0.11 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 054f1e2421105408519f4e0296607b75c32a62e1
-  data.tar.gz: a716e13987ecd1cefd7f011f3df802cf4a33a3cc
+  metadata.gz: a8c0bc3044a3d626227cd92230f5469ab88daac5
+  data.tar.gz: 1fbf45c126ddf79754f2660f9802d489d8583031
 SHA512:
-  metadata.gz: 6d1f843526f1204ee9ef9ed2994fc6cb8e4253c94387e170b50e9adc5ced0831b4838e55484fa64df19034e0869e4b3cdd0f6c5a3db3b360f54450e8b75991e3
-  data.tar.gz: 7b5f9a3622630684f2234df0e1d53d52c37a6a0bb6ee7a9b94215661a94a70156f75065922e2cc71701faac6a9a245cdd00233a82b83b5375dfa91171f9368db
+  metadata.gz: 39080aa09fef9475249937e92d0eb5c425a840c6663762ef2c896ad6326fc717e35bfcc1f698f9aa882cae6e05d47bb5caad8c0073b2e96043a49a9856a7f044
+  data.tar.gz: 95cd39ba719bd65323c84da9f5d86195faa9e68874158c40e4c872c060d328bc0a3b212d1b79841efc3240b8d09b6c505a28b57dd62aad7c2cc306b2c105b9df

data/lib/combine_pdf.rb

@@ -33,18 +33,35 @@ load "combine_pdf/combine_pdf_pdf.rb"
 
 
 # This is a pure ruby library to merge PDF files.
+#
 # In the future, this library will also allow stamping and watermarking PDFs (it allows this now, only with some issues).
 #
 # PDF objects can be used to combine or to inject data.
+#
+# here is the most basic application for the library, a one-liner that combines the PDF files and saves them:
+#   (CombinePDF.new("file1.pdf") << CombinePDF.new("file2.pdf") << CombinePDF.new("file3.pdf")).save("combined.pdf")
+#
+# == Loading PDF data
+# Loading PDF data can be done from file system or directly from the memory.
+#
+# Loading data from a file is easy:
+#   pdf = CombinePDF.new("file.pdf")
+# you can also parse PDF files from memory:
+#   pdf_data = IO.read 'file.pdf' # for this demo, load a file to memory
+#   pdf = CombinePDF.parse(pdf_data)
+# Loading from the memory is especially effective for importing PDF data recieved through the internet or from a different authoring library such as Prawn.
+#
 # == Combine/Merge PDF files or Pages
 # To combine PDF files (or data):
 #   pdf = CombinePDF.new
-#   pdf << CombinePDF.new("file1.pdf") # one way to combine, very fast.
+#   pdf << CombinePDF.new("file1.pdf")
 #   pdf << CombinePDF.new("file2.pdf")
 #   pdf.save "combined.pdf"
-# or even a one liner:
-#   (CombinePDF.new("file1.pdf") << CombinePDF.new("file2.pdf") << CombinePDF.new("file3.pdf")).save("combined.pdf")
-# you can also add just odd or even pages:
+# as demonstrated above, these can be chained for into a one-liner.
+#
+# you can also only selected pages.
+#
+# in this example, only even pages will be added:
 #   pdf = CombinePDF.new
 #   i = 0
 #   CombinePDF.new("file.pdf").pages.each do |page|
@@ -52,12 +69,12 @@ load "combine_pdf/combine_pdf_pdf.rb"
 #     pdf << page if i.even?
 #   end
 #   pdf.save "even_pages.pdf"
-# notice that adding all the pages one by one is slower then adding the whole file.
+# notice that adding the whole file is faster then adding each page seperately.
 # == Add content to existing pages (Stamp / Watermark)
 # To add content to existing PDF pages, first import the new content from an existing PDF file.
 # after that, add the content to each of the pages in your existing PDF.
 #
-# in this example, we will add a company logo to each page:
+# in this example, a company logo will be stamped over each page:
 #   company_logo = CombinePDF.new("company_logo.pdf").pages[0]
 #   pdf = CombinePDF.new "content_file.pdf"
 #   pdf.pages.each {|page| page << company_logo} # notice the << operator is on a page and not a PDF object.
@@ -77,16 +94,40 @@ load "combine_pdf/combine_pdf_pdf.rb"
 #   pdf.save "file_with_numbering.pdf"
 #
 # numbering can be done with many different options, with different formating, with or without a box object, and even with opacity values.
+# == Writing Content
+# page numbering actually adds content using the PDFWriter object (a very basic writer).
+#
+# in this example, all the PDF pages will be stamped, along the top, with a red box, with blue text, stating "Draft, page #".
+# here is the easy way (we can even use "number_pages" without page numbers, if we wish):
+#   pdf = CombinePDF.new "file_to_stamp.pdf"
+#   pdf.number_pages number_format: " - Draft, page %d - ", number_location: [:top], font_color: [0,0,1], box_color: [0.4,0,0], opacity: 0.75, font_size:16
+#   pdf.save "draft.pdf"
+#
+# for demntration, it will now be coded the hard way, just so we can play more directly with some of the data.
+#
+#   pdf = CombinePDF.new "file_to_stamp.pdf"
+#   ipage_number = 1
+#   pdf.pages.each do |page|
+#     # create a "stamp" PDF page with the same size as the target page
+#     # we will do this because we will use this to center the box in the page
+#     mediabox = page[:MediaBox]
+#     # CombinePDF is pointer based...
+#     # so you can add the stamp to the page and still continue to edit it's content!
+#     stamp = PDFWriter.new mediabox
+#     page << stamp
+#     # set the visible dimensions to the CropBox, if it exists.
+#     cropbox = page[:CropBox]
+#     mediabox = cropbox if cropbox
+#     # set stamp text
+#     text = " Draft (page %d) " % page_number
+#     # write the textbox
+#     stamp.textbox text, x: mediabox[0]+30, y: mediabox[1]+30, width: mediabox[2]-mediabox[0]-60, height: mediabox[3]-mediabox[1]-60, font_color: [0,0,1], font_size: :fit_text, box_color: [0.4,0,0], opacity: 0.5
+#   end
+#   pdf.save "draft.pdf"
 #
-# == Loading PDF data
-# Loading PDF data can be done from file system or directly from the memory.
 #
-# Loading data from a file is easy:
-#   pdf = CombinePDF.new("file.pdf")
-# you can also parse PDF files from memory:
-#   pdf_data = IO.read 'file.pdf' # for this demo, load a file to memory
-#   pdf = CombinePDF.parse(pdf_data)
-# Loading from the memory is especially effective for importing PDF data recieved through the internet or from a different authoring library such as Prawn.
+# font support for the writer is still in the works and is extreamly limited.
+# at the moment it is best to limit the fonts to the 14 standard latin fonts (no unicode).
 #
 # == Decryption & Filters
 #
@@ -132,10 +173,47 @@ module CombinePDF
 		PDF.new( PDFParser.new(data) )
 	end
 	# makes a PDFWriter object
+	#
+	# PDFWriter objects reresent an empty page and have the method "textbox"
+	# that adds content to that page.
+	#
+	# PDFWriter objects are used internally for numbering pages (by creating a PDF page
+	# with the page number and "stamping" it over the existing page).
+	#
 	# ::mediabox an Array representing the size of the PDF document. defaults to: [0.0, 0.0, 612.0, 792.0]
+	#
+	# if the page is PDFWriter object as a stamp, the final size will be that of the original page.
 	def create_page(mediabox = [0.0, 0.0, 612.0, 792.0])
 		PDFWriter.new mediabox
 	end
+
+	# adds a correctly formatted font object to the font library.
+	#
+	# registered fonts will remain in the library and will only be embeded in
+	# PDF objects when they are used by PDFWriter objects (for example, for numbering pages).
+	#
+	# this function enables plug-ins to expend the font functionality of CombinePDF.
+	#
+	# font_name:: a Symbol with the name of the font. if the fonts exists in the library, it will be overwritten!
+	# font_metrics:: a Hash of font metrics, of the format char => {wx: char_width, boundingbox: [left_x, buttom_y, right_x, top_y]} where char == character itself (i.e. " " for space). The Hash should contain a special value :missing for the metrics of missing characters. an optional :wy might be supported in the future, for up to down fonts.
+	# font_pdf_object:: a Hash in the internal format recognized by CombinePDF, that represents the font object.
+	# font_cmap:: a CMap dictionary Hash) which maps unicode characters to the hex CID for the font (i.e. {"a" => "61", "z" => "7a" }).
+	def register_font(font_name, font_metrics, font_pdf_object, font_cmap = nil)
+		Fonts.register_font font_name, font_metrics, font_pdf_object, font_cmap
+	end
+
+	# adds an existing font (from any PDF Object) to the font library.
+	#
+	# returns the font on success or false on failure.
+	#
+	# VERY LIMITTED SUPPORT:
+	# - at the moment it only imports Type0 fonts.
+	# - also, to extract the Hash of the actual font object you were looking for, is not a trivial matter. I do it on the console.
+	# font_name:: a Symbol with the name of the font registry. if the fonts exists in the library, it will be overwritten! 
+	# font_object:: a Hash in the internal format recognized by CombinePDF, that represents the font object.
+	def register_font_from_pdf_object font_name, font_object
+		Fonts.register_font_from_pdf_object font_name, font_object
+	end
 end
 
 

data/lib/combine_pdf/combine_pdf_basic_writer.rb

@@ -44,6 +44,7 @@ module CombinePDF
 		def initialize(mediabox = [0.0, 0.0, 612.0, 792.0])
 			# indirect_reference_id, :indirect_generation_number
 			@contents = ""
+			@base_font_name = "Writer" + SecureRandom.urlsafe_base64(7) + "PDF"
 			self[:Type] = :Page
 			self[:indirect_reference_id] = 0
 			self[:Resources] = {}
@@ -67,11 +68,11 @@ module CombinePDF
 		# 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.
-		# length:: the length of the box. negative values will be computed from edge of page. defaults to 0 (end of page).
+		# 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"
-		# font:: a Symbol representing one of the 14 standard fonts. defaults to ":Helvetica". the options are:
+		# 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"
@@ -100,11 +101,11 @@ module CombinePDF
 			options = {
 				x: 0,
 				y: 0,
-				length: 0,
+				width: 0,
 				height: -1,
 				text_align: :center,
 				text_valign: :center,
-				font: :Helvetica,
+				font: nil,
 				font_size: :fit_text,
 				max_font_size: nil,
 				font_color: [0,0,0],
@@ -118,15 +119,8 @@ module CombinePDF
 			}
 			options.update properties
 			# reset the length and height to meaningful values, if negative
-			options[:length] = mediabox[2] - options[:x] + options[:length] if options[:length] <= 0
+			options[:width] = mediabox[2] - options[:x] + options[:width] if options[:width] <= 0
 			options[:height] = mediabox[3] - options[:y] + options[:height] if options[:height] <= 0
-			# fit text in box, if requested
-			font_size = options[:font_size]
-			if options[:font_size] == :fit_text
-				font_size = self.fit_text text, options[:font], options[:length], options[:height]
-				font_size = options[:max_font_size] if options[:max_font_size] && font_size > options[:max_font_size]
-			end
-
 
 			# create box stream
 			box_stream = ""
@@ -146,29 +140,29 @@ module CombinePDF
 				box_stream << "#{PDFOperations._object_to_pdf box_graphic_state} gs\n"
 				box_stream << "DeviceRGB CS\nDeviceRGB cs\n"
 				if options[:box_color]
-					box_stream << "#{options[:box_color].join(' ')} scn\n"
+					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(' ')} SCN\n"
+					box_stream << "#{options[:border_color].join(' ')} RG\n"
 				end
 				# create the path
 				radius = options[:box_radius]
-				half_radius = radius.to_f / 2
+				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[:length] - radius} #{options[:y]} l\n" #buttom
+				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[:length] - half_radius} #{options[:y]} "
-					box_stream << "#{options[:x] + options[:length]} #{options[:y] + half_radius} "
-					box_stream << "#{options[:x] + options[:length]} #{options[:y] + radius} c\n"
+					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[:length]} #{options[:y] + options[:height] - radius} l\n"
+				box_stream << "#{options[:x] + options[:width]} #{options[:y] + options[:height] - radius} l\n"
 				if options[:box_radius] != 0
-					box_stream << "#{options[:x] + options[:length]} #{options[:y] + options[:height] - half_radius} "
-					box_stream << "#{options[:x] + options[:length] - half_radius} #{options[:y] + options[:height]} "
-					box_stream << "#{options[:x] + options[:length] - radius} #{options[:y] + options[:height]} c\n"
+					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"
@@ -203,19 +197,26 @@ module CombinePDF
 			# each unit (1) is 1/72 Inch
 			# create text stream
 			text_stream = ""
-			if text.to_s != "" && font_size != 0 && (options[:font_color] || options[:stroke_color])
+			if text.to_s != "" && options[:font_size] != 0 && (options[:font_color] || options[:stroke_color])
 				# compute x and y position for text
 				x = options[:x]
 				y = options[:y]
 
-				font_object = Fonts.get_font(options[:font])
+				# 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], options[:height]
+					font_size = options[:max_font_size] if options[:max_font_size] && font_size > options[:max_font_size]
+				end
 
-				text_size = font_object.dimensions_of text, font_size
+				text_size = dimensions_of text, fonts, font_size
 
 				if options[:text_align] == :center
-					x = (options[:length] - text_size[0])/2 + x
+					x = (options[:width] - text_size[0])/2 + x
 				elsif options[:text_align] == :right
-					x = (options[:length] - text_size[0]) + x
+					x = (options[:width] - text_size[0]) + x
 				end
 				if options[:text_valign] == :center
 					y = (options[:height] - text_size[1])/2 + y
@@ -230,10 +231,10 @@ module CombinePDF
 				text_stream << "DeviceRGB CS\nDeviceRGB cs\n"
 				# set text render mode
 				if options[:font_color]
-					text_stream << "#{options[:font_color].join(' ')} scn\n"
+					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(' ')} SCN\n"
+					text_stream << "#{options[:stroke_color].join(' ')} RG\n"
 					if options[:font_color]
 						text_stream << "2 Tr\n"
 					else
@@ -244,14 +245,19 @@ module CombinePDF
 				else
 					text_stream << "3 Tr\n"
 				end
-				# format text object
-				text_stream << "BT\n" # the Begine Text marker			
-				text_stream << PDFOperations._format_name_to_pdf(set_font options[:font]) # Set font name
-				text_stream << " #{font_size} Tf\n" # set font size and add font operator
-				text_stream << "#{options[:font_color].join(' ')} rg\n" # sets the color state
-				text_stream << "#{x} #{y} Td\n" # set location for text object
-				text_stream << (  font_object.encode(text)  ) # insert the string in PDF format, after mapping to font glyphs
-				text_stream << " Tj\n ET\n" # the Text object operator and the End Text marker
+				# 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} 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\nQ\nQ\n"
 			end
@@ -259,8 +265,13 @@ module CombinePDF
 
 			self
 		end
-		def dimensions_of(text, font_name, size = 1000)
-			Fonts.get_font(font_name).dimensions_of text, size
+		# 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
@@ -273,7 +284,7 @@ module CombinePDF
 		def fit_text(text, font, length, height = 10000000)
 			size = 100000
 			size_array = [size]
-			metrics = Fonts.get_font(font).dimensions_of text, size
+			metrics = Fonts.dimensions_of text, font, size
 			if metrics[0] > length
 				size_array << size * length/metrics[0]
 			end
@@ -282,6 +293,8 @@ module CombinePDF
 			end
 			size_array.min
 		end
+
+
 		protected
 
 		# accessor (getter) for the :Resources element of the page
@@ -295,7 +308,7 @@ module CombinePDF
 		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 14 Type 1 fonts, known as the standard 14 fonts:
+		# font:: a Symbol of one of the fonts registered in the library, or:
 		# - :"Times-Roman"
 		# - :"Times-Bold"
 		# - :"Times-Italic"
@@ -319,7 +332,7 @@ module CombinePDF
 				end
 			end
 			# set a secure name for the font
-			name = (SecureRandom.urlsafe_base64(9)).to_sym
+			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.
@@ -329,6 +342,8 @@ module CombinePDF
 			#return name
 			name
 		end
+		# register or get a registered graphoc 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] ||= {}
@@ -346,6 +361,60 @@ module CombinePDF
 			#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"
+			return text unless text =~ /[#{rtl_characters}]/
+
+			out = []
+			scanner = StringScanner.new text
+			until scanner.eos? do
+				if scanner.scan /[#{rtl_characters}]/
+					out.unshift scanner.matched
+				end
+				if scanner.scan /[^#{rtl_characters}]+/
+					out.unshift scanner.matched
+				end
+			end
+			out.join
+		end
 	end
 	
 end

data/lib/combine_pdf/combine_pdf_fonts.rb

@@ -47,28 +47,6 @@ module CombinePDF
 				self[:referenced_object] = object
 			end
 
-			# This function calculates the dimensions of a string in a PDF.
-			#
-			# UNICODE SUPPORT IS FONT DEPENDENT!
-			#
-			# text:: String containing the text for which the demantion box will be calculated.
-			# size:: the size of the text, as it will be applied in the PDF.
-			def dimensions_of(text, size = 1000)
-				metrics_array = []
-				# the following is only good for latin text - unicode support is missing!!!!
-				text.each_char do |c|
-					metrics_array << (self.metrics[c] or self.metrics[:missing])
-				end
-				height = metrics_array.map {|m| m ? m[:boundingbox][3] : 0} .max
-				height = height - (metrics_array.map {|m| m ? m[:boundingbox][1] : 0} ).min
-				width = 0.0
-				metrics_array.each do |m|
-					width += (m[:wx] or m[:wy])
-				end
-				return [height.to_f/1000*size, width.to_f/1000*size] if metrics_array[0][:wy]
-				[width.to_f/1000*size, height.to_f/1000*size]
-			end
-
 			# This function translate a unicode string, to a character glyph ID stream.
 			def encode text
 				# FixMe: embed RTL text convertion
@@ -112,8 +90,9 @@ module CombinePDF
 
 		# adds a correctly formatted font object to the font library.
 		# font_name:: a Symbol with the name of the font. if the fonts exists, it will be overwritten!
-		# font_metrics:: a Hash of ont metrics, of the format i => {wx: char_width, boundingbox: [left_x, buttom_y, right_x, top_y]} where i == character code (i.e. 32 for space). The Hash should contain a special value :missing for the metrics of missing characters. an optional :wy will be supported in the future, for up to down fonts.
+		# font_metrics:: a Hash of ont metrics, of the format char => {wx: char_width, boundingbox: [left_x, buttom_y, right_x, top_y]} where i == character code (i.e. 32 for space). The Hash should contain a special value :missing for the metrics of missing characters. an optional :wy will be supported in the future, for up to down fonts.
 		# font_pdf_object:: a Hash in the internal format recognized by CombinePDF, that represents the font object.
+		# font_cmap:: a CMap dictionary Hash) which maps unicode characters to the hex CID for the font (i.e. {"a" => "61", "z" => "7a" }).
 		def register_font(font_name, font_metrics, font_pdf_object, font_cmap = nil)
 			new_font = Font.new
 			new_font.name = font_name
@@ -125,17 +104,37 @@ module CombinePDF
 			new_font
 		end
 
-		# This function calculates the dimensions of a string in a PDF.
-		#
-		# UNICODE SUPPORT IS MISSING!
+		# gets the dimentions (width and height) of the text, as it will be printed in the PDF.
 		#
-		# text:: String containing the text for which the demantion box will be calculated.
-		# font:: the font name, from the 14 fonts possible. @see font
-		# size:: the size of the text, as it will be applied in the PDF.
-		def dimensions_of(text, font_name, size = 1000)
-			get_font(font_name).dimensions_of text, size
-		end
+		# text:: the text to measure
+		# fonts:: 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 = [fonts] unless fonts.is_a? Array
+			merged_metrics = {}
+			# merge the metrics last to first (so that important fonts override secondary fonts)
+			fonts.length.downto(1).each do |i|
+				f = get_font(fonts[i-1])
+				if f && f.metrics
+					merged_metrics.update( get_font(fonts[i-1]).metrics)
+				else
+					warn "metrics of font not found!"
+				end
+			end
 
+			metrics_array = []
+			text.each_char do |c|
+				metrics_array << (merged_metrics[c] || {wx: 0, boundingbox: [0,0,0,0]})
+			end
+			height = metrics_array.map {|m| m ? m[:boundingbox][3] : 0} .max
+			height = height - (metrics_array.map {|m| m ? m[:boundingbox][1] : 0} ).min
+			width = 0.0
+			metrics_array.each do |m|
+				width += (m[:wx] || m[:wy])
+			end
+			return [height.to_f/1000*size, width.to_f/1000*size] if metrics_array[0][:wy]
+			[width.to_f/1000*size, height.to_f/1000*size]
+		end
 		# this function registers the 14 standard fonts to the library.
 		#
 		# it will be called when the module first requests a font from the library.
@@ -185,7 +184,7 @@ module CombinePDF
 			end
 		end
 
-		# Register a fong that already exists in the pdf object into the font library.
+		# Register a font that already exists in a pdf object into the font library.
 		# DOESN'T WORK YET!!!
 		def register_font_from_pdf_object font_name, font_object
 			# FIXME:

data/lib/combine_pdf/combine_pdf_pdf.rb

@@ -290,7 +290,7 @@ module CombinePDF
 		# - :margin_from_height a number (PDF points) for the top and buttom margins. defaults to 45.
 		# - :margin_from_side a number (PDF points) for the left and right margins. defaults to 15.
 		# the options Hash can also take all the options for PDFWriter.textbox.
-		# defaults to font_name: :Helvetica, font_size: 12 and no box (:border_width => 0, :box_color => nil).
+		# defaults to font: :Helvetica, font_size: 12 and no box (:border_width => 0, :box_color => nil).
 		def number_pages(options = {})
 			opt = {
 				number_format: ' - %s - ',
@@ -316,7 +316,7 @@ module CombinePDF
 				text_dimantions = stamp.dimensions_of( text, opt[:font], opt[:font_size] )
 				box_width = text_dimantions[0] * 1.2
 				box_height = text_dimantions[1] * 2
-				opt[:length] = box_width
+				opt[:width] = box_width
 				opt[:height] = box_height
 				from_height = 45
 				from_side = 15

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: combine_pdf
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors:
 - Boaz Segev
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-04 00:00:00.000000000 Z
+date: 2014-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-rc4