ifmapper 0.5 → 0.6

data/lib/IFMapper/MapPrinting.rb

@@ -0,0 +1,161 @@
+
+# Common printing add-ons
+class FXSection
+  attr_accessor :xoff, :yoff, :page, :pxlen, :pylen, :rotate
+end
+
+class Page
+  attr_accessor :xlen, :ylen, :sections, :rotate
+  def initialize(xlen = 0, ylen = 0)
+    @xlen     = xlen
+    @ylen     = ylen
+    @rotate   = false
+    @sections = []
+  end
+end
+
+class Map  
+  #
+  # This code section is largely a copy of similar code used in
+  # IFM's C code.
+  # It tries to pack multiple map sections into a single page.
+  #
+  def pack_sections(xmax, ymax)
+    spacing = 0.0
+
+    # initialize -- one section per page
+    pages = []
+    @sections.each { |sect|
+      xlen, ylen = sect.rooms_width_height
+      sect.xoff = 0.0
+      sect.yoff = 0.0
+
+      page = Page.new(xlen+2, ylen+2)
+      pages.push page
+      page.sections << sect
+    }
+
+    ratio   = xmax.to_f / ymax
+
+    packed  = 1
+    while packed > 0
+      newpages = []
+      pos = packed = 0
+      while pos < pages.size
+	p1 = pages[pos]
+	x1 = p1.xlen
+	y1 = p1.ylen
+
+	# Check if it's better off rotated
+	p1.rotate = ((x1 < y1 and xmax > ymax) or
+		     (x1 > y1 and xmax < ymax))
+
+	# Check if this is the last page
+	if pos + 1 == pages.size
+	  newpages.push p1
+	  break
+	end
+	
+	# Get following page
+	p2 = pages[pos+1]
+	x2 = p2.xlen
+	y2 = p2.ylen
+	
+	# Try combining pages in X direction
+	xc1 = x1 + x2 + spacing
+	yc1 = [y1, y2].max
+	v1  = (xc1 <= xmax and yc1 <= ymax)
+	r1  = xc1.to_f / yc1
+	
+	# Try combining pages in Y direction
+	xc2 = [x1, x2].max
+	yc2 = y1 + y2 + spacing
+	v2  = (xc2 <= xmax and yc2 <= ymax)
+	r2  = xc2.to_f / yc2
+
+	# See which is best
+	if v1 and v2
+	  if (ratio - r1).abs < (ratio - r2).abs
+	    v2 = false
+	  else
+	    v1 = false
+	  end
+	end
+	
+	# Just copy page if nothing can be done
+	if not v1 and not v2
+	  newpages.push(p1)
+	  pos += 1
+	  next
+	end
+	
+	# Create merged page
+	page = Page.new
+	xo1 = yo1 = xo2 = yo2 = 0
+	
+	if v1
+	  page.xlen = xc1
+	  page.ylen = yc1
+	  xo2 = x1 + spacing
+	  
+	  if y1 < y2
+	    yo1 = (yc1 - y1) / 2
+	  else
+	    yo2 = (yc1 - y2) / 2
+	  end
+	end
+	
+	if v2
+	  page.xlen = xc2
+	  page.ylen = yc2
+	  yo1 = y2 + spacing
+	  
+	  if x1 < x2
+	    xo1 = (xc2 - x1) / 2
+	  else
+	    xo2 = (xc2 - x2) / 2
+	  end
+	end
+	
+	# Copy sections to new page, updating offsets
+	opsects = p1.sections
+	opsects.each { |sect|
+	  page.sections.push sect
+	  sect.xoff += xo1
+	  sect.yoff += yo1
+	}
+	
+	opsects = p2.sections
+	opsects.each { |sect|
+	  page.sections.push sect
+	  sect.xoff += xo2
+	  sect.yoff += yo2
+	}
+	
+	# Add merged page to list and go to next page pair
+	newpages.push page
+	pos += 2
+	packed += 1
+      end
+      pages = newpages
+    end
+
+    # Give each section its page info and clean up
+    num = 0
+    pages.each { |page|
+      psects = page.sections
+      xlen  = page.xlen
+      ylen  = page.ylen
+      rflag = page.rotate
+
+      num += 1
+      psects.each { |sect|
+	sect.page   = num
+	sect.pxlen  = xlen
+	sect.pylen  = ylen
+	sect.rotate = rflag
+      }
+    }
+    return num
+  end
+end

data/lib/IFMapper/PDFMapExporter.rb

@@ -11,6 +11,8 @@ rescue => e
   raise "Please install 'pdf writer' library for Acrobat PDF support."
 end
 
+require 'IFMapper/MapPrinting'
+
 PDF_ZOOM        = 0.5
 PDF_ROOM_WIDTH  = W  * PDF_ZOOM  # 60
 PDF_ROOM_HEIGHT = H  * PDF_ZOOM  # 37.5
@@ -18,7 +20,6 @@ PDF_ROOM_WS     = WS * PDF_ZOOM
 PDF_ROOM_HS     = HS * PDF_ZOOM
 PDF_MARGIN      = 20
 
-
 #
 # Open all the map class and add all pdf methods there
 # Gotta love Ruby's flexibility to just inject in new methods.
@@ -87,8 +88,8 @@ class FXConnection
     return if not @roomB # PDF does not print unfinished complex connections
 
     dir    = @roomA.exits.index(self)
-    x1, y1 = @roomA.pdf_corner(pdf, opts, self, dir)
-    x2, y2 = @roomB.pdf_corner(pdf, opts, self)
+    x1, y1 = @roomA.pdf_corner(opts, self, dir)
+    x2, y2 = @roomB.pdf_corner(opts, self)
     pdf.move_to(x1, y1)
     pdf.line_to(x2, y2).stroke
     pdf_draw_arrow(pdf, opts, x1, y1, x2, y2)
@@ -102,8 +103,49 @@ class FXConnection
     end
   end
 
+  #
+  # Draw the connection text next to the arrow ('I', 'O', etc)
+  #
+  def pdf_draw_text(pdf, x, y, dir, text, arrow)
+    if dir == 7 or dir < 6 and dir != 1
+      if arrow and (dir == 0 or dir == 4)
+	x += 5
+      end
+      x += 2.5
+    elsif dir == 6 or dir == 1
+      x -= 7.5
+    end
+    
+    if dir > 5 or dir < 4
+      if arrow and (dir == 6 or dir == 2)
+	y += 5
+      end
+      y += 2.5
+    elsif dir == 4 or dir == 5
+      y -= 7.5
+    end
+    
+    font_size = 8
+    pdf.add_text(x, y, text, font_size)
+  end
+
+  def pdf_draw_exit_text(pdf, opts)
+    if @exitAtext != 0
+      dir  = @roomA.exits.index(self)
+      x, y = @roomA.pdf_corner(opts, self, dir)
+      pdf_draw_text( pdf, x, y, dir, 
+		   EXIT_TEXT[@exitAtext], @dir == BtoA)
+    end
+    if @exitBtext != 0
+      dir  = @roomB.exits.rindex(self)
+      x, y = @roomB.pdf_corner(opts, self, dir)
+      pdf_draw_text( pdf, x, y, dir, 
+		    EXIT_TEXT[@exitBtext], @dir == AtoB)
+    end
+  end
+
   def pdf_draw(pdf, opts)
-    # pdf_draw_exit_text(pdf, opts)
+    pdf_draw_exit_text(pdf, opts)
     if @type == SPECIAL
       s = PDF::Writer::StrokeStyle.new(2, :dash => { 
 					 :pattern => [2],
@@ -128,7 +170,7 @@ end
 
 
 class FXRoom
-  def pdf_corner( pdf, opts, c, idx = nil )
+  def pdf_corner( opts, c, idx = nil )
     x, y = _corner(c, idx)
     y = -y
 
@@ -160,30 +202,46 @@ class FXRoom
     pdf.rectangle(x, y, opts['w'], opts['h']).fill_stroke
   end
 
+  def pdf_draw_text( pdf, opts, x, y, text, font_size )
+    miny  = (opts['height'] - @y) * opts['hh'] + opts['hs_2'] + 
+      opts['margin_2']
+    while text != ''
+      text = pdf.add_text_wrap(x, y, opts['w'] - 2, text, font_size)
+      y -= font_size
+      break if y <= miny
+    end
+    return [x, y]
+  end
+
+  def pdf_draw_objects(pdf, opts, x, y)
+    font_size = 6
+    objs = @objects.split("\n")
+    objs = objs.join(', ')
+    return pdf_draw_text( pdf, opts, x, y, objs, font_size )
+  end
+
   def pdf_draw_name(pdf, opts)
     # We could also use pdf_corner(7) here
     x = @x * opts['ww'] + opts['margin_2'] + opts['ws_2'] + 2
     y = opts['height'] - @y
-    y = y * opts['hh'] + opts['margin_2'] + opts['hs_2'] + opts['h'] - 10
     font_size = 8
+    y = y * opts['hh'] + opts['margin_2'] + opts['hs_2'] + opts['h'] - 
+      (font_size + 2)
     pdf.stroke_color(Color::RGB::Black)
     pdf.fill_color(Color::RGB::Black)
-    text = @name
-    while text != ''
-      text = pdf.add_text_wrap(x, y, opts['w'], text, font_size)
-      y -= font_size
-    end
+    return pdf_draw_text( pdf, opts, x, y, @name, font_size )
   end
 
   def pdf_draw( pdf, opts, idx )
     pdf_draw_box( pdf, opts )
-    pdf_draw_name( pdf, opts )
+    x, y = pdf_draw_name( pdf, opts )
+    pdf_draw_objects(pdf, opts, x, y)
   end
 end
 
 
 
-class FXPage
+class FXSection
 
   def pdf_draw_grid(pdf, opts, w, h )
     (0...w).each { |xx|
@@ -195,68 +253,80 @@ class FXPage
     }
   end
 
-  def pdf_draw_mapname( pdf, opts, mapname )
-    return if not mapname or mapname == ''
-    pdf.text( mapname,
-	     :font_size => 24,
-	     :justification => :center
-	     )
-  end
 
-  def pdf_draw_pagename( pdf, opts )
+  def pdf_draw_section_name( pdf, opts )
     return if not @name or @name == ''
-    pdf.text( @name,
-	     :font_size => 16,
-	     :justification => :center
-	     )
+    y = (opts['height']) * opts['hh'] + 16
+    xymin, xymax = min_max_rooms
+    x = (xymax[0] + 2) * opts['ww'] / 2
+    pdf.add_text( x, y, @name, 16 )
   end
 
 
   def pdf_draw(pdf, opts, mapname )
-    width, height = rooms_width_height
-
-    #
-    #  Determine if better to print page in landscape mode
-    #
-    landscape = false
-    if landscape
+    if rotate
       pdf.rotate_axis(90.0)
-      pdf.translate_axis( 0, -pdf.page_width )
+      pdf.translate_axis( 0, -pdf.page_height )
     end
 
+    # Move section to its position in page
+    pack = [@xoff * opts['ww'], @yoff * -opts['hh']]
+    pdf.translate_axis( pack[0], pack[1] )
+
     # Use times-roman as font
     pdf.select_font 'Times-Roman'
     pdf.stroke_color(Color::RGB::Black)
     pdf.fill_color(Color::RGB::Black)
 
-    pdf_draw_mapname( pdf, opts, mapname )
-    pdf_draw_pagename( pdf, opts )
+    pdf_draw_section_name( pdf, opts )
+
+    xymin, = min_max_rooms
+
+    x = -(xymin[0]-1) * opts['ww']
+    y =  (xymin[1]-1) * opts['hh']
+    pdf.translate_axis( x, y )
 
     # For testing purposes only, draw grid of boxes
     # pdf_draw_grid( pdf, opts, width, height )
-
     @connections.each { |c| c.pdf_draw( pdf, opts ) }
     @rooms.each_with_index { |r, idx| r.pdf_draw( pdf, opts, idx) }
+
+    # Reset axis
+    pdf.translate_axis(-x, -y)
+    pdf.translate_axis(-pack[0], -pack[1])
   end
 end
 
 
 class FXMap
 
-  def pdf_draw_pages( pdf, opts )
-    old_page = @page
-    @pages.each_with_index { |p, idx|
-      pdf.start_new_page if idx > 0
-      @page = idx
+  def pdf_draw_mapname( pdf, opts )
+    return if not @name or @name == ''
+    pdf.text( @name,
+	     :font_size => 24,
+	     :justification => :center
+	     )
+  end
+
+  def pdf_draw_sections( pdf, opts )
+    old_section = @section
+    page        = -1
+    @sections.each_with_index { |sect, idx|
+      if page != sect.page
+	page = sect.page
+	pdf.start_new_page if page > 1
+	pdf_draw_mapname( pdf, opts )
+      end
+      @section = idx
       # For each page, we need to regenerate the pathmap so that complex
       # paths will come out ok.
       create_pathmap
       # Now, we draw it
-      p.pdf_draw(pdf, opts, @name)
+      sect.pdf_draw(pdf, opts, @name)
     }
 
     # Restore original viewing page
-    @page = old_page
+    @section = old_section
     create_pathmap
   end
 
@@ -265,6 +335,8 @@ class FXMap
     paper = 'LETTER'
     if printer
       case printer.mediasize
+      when FXPrinter::MEDIA_LETTER
+	paper = 'LETTER'
       when FXPrinter::MEDIA_LEGAL
 	paper = 'LEGAL'
       when FXPrinter::MEDIA_A4
@@ -281,10 +353,14 @@ class FXMap
 
 
     pdf_options = @options.dup
+
+    ww = PDF_ROOM_WIDTH  + PDF_ROOM_WS
+    hh = PDF_ROOM_HEIGHT + PDF_ROOM_HS
+
     pdf_options.merge!( 
 		       { 
-			 'ww'       => PDF_ROOM_WIDTH  + PDF_ROOM_WS,
-			 'hh'       => PDF_ROOM_HEIGHT + PDF_ROOM_HS,
+			 'ww'       => ww,
+			 'hh'       => hh,
 			 'w'        => PDF_ROOM_WIDTH,
 			 'h'        => PDF_ROOM_HEIGHT,
 			 'ws'       => PDF_ROOM_WS,
@@ -293,18 +369,19 @@ class FXMap
 			 'hs_2'     => PDF_ROOM_HS / 2.0,
 			 'margin'   => PDF_MARGIN,
 			 'margin_2' => PDF_MARGIN / 2.0,
-			 'width'    => @width  - 1,
-			 'height'   => @height - 1,
+			 'width'    => (pdf.page_width / ww).to_i  - 1,
+			 'height'   => (pdf.page_height / hh).to_i - 1,
 		       }
 		       )
 
 
     begin
-      # See if it is possible to pack several map sections (pages) into
+      # See if it is possible to pack several map sections (sections) into
       # a single print page.
-      # pack_sections
-      pdf_draw_pages(pdf, pdf_options)
-      p "Saving pdf to '#{pdffile}'..."
+      num = pack_sections( pdf_options['width'] + 2, 
+			  pdf_options['height'] + 2 )
+      pdf_draw_sections(pdf, pdf_options)
+      status "Exporting PDF file '#{pdffile}'"
       pdf.save_as(pdffile)
     rescue => e
       p e