ifmapper 0.5

data/lib/IFMapper/Map.rb

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+
+require 'IFMapper/Room'
+require 'IFMapper/Page'
+
+class Map
+  attr_accessor :name
+  attr_accessor :creator
+  attr_accessor :date
+
+  attr_reader   :page
+  attr_accessor :pages
+
+  attr_accessor :width
+  attr_accessor :height
+
+  def page=(x)
+    x = 0               if x < 0 
+    x = @pages.size - 1 if x >= @pages.size
+    @page = x
+  end
+
+  #
+  # Used for loading class with Marshal
+  #
+  def marshal_load(v)
+    @name = v.shift
+    @creator = v.shift
+    @date = v.shift
+    @page = v.shift
+    @pages = v.shift
+    @width = v.shift
+    @height = v.shift
+  end
+
+  #
+  # Used for saving class with Marshal
+  #
+  def marshal_dump
+    [ @name, @creator, @date, @page, @pages, @width, @height ] 
+  end
+
+  def initialize(name)
+    @page    = 0
+    @name    = name
+    @creator = ''
+
+    # if printing sideways
+    @width  = 20
+    @height = 20
+
+    # Add at least one page
+    @pages = []
+    new_page
+  end
+
+  def copy(b)
+    @page    = b.page
+    @pages   = b.pages
+    @name    = b.name
+    @creator = b.creator
+    @width   = b.width
+    @height  = b.height
+    @date    = b.date
+  end
+
+  def delete_connection(c)
+    @pages[@page].delete_connection(c)
+  end
+
+  def delete_connection_at( idx )
+    @pages[@page].delete_connection_at(idx)
+  end
+
+
+  def new_connection( roomA, exitA, roomB, exitB = nil )
+    @pages[@page].new_connection(roomA, exitA, roomB, exitB)
+  end
+
+
+  def delete_room_at(idx)
+    @pages[@page].delete_room_at(idx)
+  end
+
+  def delete_room(r)
+    @pages[@page].delete_room(r)
+  end
+
+  def new_room( x, y )
+    @pages[@page].new_room(x, y)
+  end
+
+  def new_page
+    @pages.push( Page.new )
+    @page = @pages.size - 1
+  end
+
+  def _check_page
+    @page = @pages.size - 1 if @page >= @pages.size
+    new_page if @pages.size == 0
+  end
+
+  def delete_page_at(idx)
+    @pages.delete_at(idx)
+    _check_page
+  end
+
+end
+
+

data/lib/IFMapper/PDFMapExporter.rb

@@ -0,0 +1,315 @@
+
+begin
+  require 'tmpdir'
+rescue => e
+  raise "Please install 'tmpdir' library.  This is needed for printing."
+end
+
+begin
+  require 'pdf/writer'
+rescue => e
+  raise "Please install 'pdf writer' library for Acrobat PDF support."
+end
+
+PDF_ZOOM        = 0.5
+PDF_ROOM_WIDTH  = W  * PDF_ZOOM  # 60
+PDF_ROOM_HEIGHT = H  * PDF_ZOOM  # 37.5
+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.
+#
+class FXConnection
+  def _cvt_pt(p, opts)
+    x = (p[0] - WW / 2.0) / WW.to_f
+    y = (p[1] - HH / 2.0) / HH.to_f
+    x = x * opts['ww'] + opts['ws_2'] + opts['margin_2'] + opts['w'] / 2.0
+    y = (opts['height'] - y) * opts['hh'] + opts['hs_2'] + opts['margin_2'] + opts['hs']
+    return [x, y]
+  end
+
+  def pdf_draw_arrow(pdf, opts, x1, y1, x2, y2)
+    return if @dir == BOTH
+    
+    pt1, d = _arrow_info( x1, y1, x2, y2, 0.5 )
+
+    p = []
+    p << PDF::Writer::PolygonPoint.new( pt1[0], pt1[1] )
+    p << PDF::Writer::PolygonPoint.new( pt1[0] + d[0], pt1[1] - d[1] )
+    p << PDF::Writer::PolygonPoint.new( pt1[0] + d[1], pt1[1] + d[0] )
+    pdf.fill_color    Color::RGB::Black
+    pdf.polygon(p).fill
+  end
+
+  def pdf_draw_complex_as_bspline( pdf, opts )
+    p = []
+    p << _cvt_pt(@pts[0], opts)
+    p << p[0]
+    p << p[0]
+    @pts.each { |pt|
+      p << _cvt_pt(pt, opts)
+    }
+    p << p[-1]
+    p << p[-1]
+    p << p[-1]
+    return FXSpline::bspline(p)
+  end
+
+  def pdf_draw_complex_as_lines( pdf, opts )
+    p = []
+    maxy = opts['height'] * opts['hh'] + opts['hs_2'] + opts['margin_2'] 
+    @pts.each { |pt|
+      p << [ pt[0] * PDF_ZOOM, maxy - pt[1] * PDF_ZOOM ]
+    }
+    return p
+  end
+
+  def pdf_draw_complex( pdf, opts )
+    if opts['Paths as Curves']
+      p = pdf_draw_complex_as_bspline( pdf, opts )
+    else
+      p = pdf_draw_complex_as_lines( pdf, opts )
+    end
+    pdf.move_to( p[0][0], p[0][1] )
+    p.each { |pt| pdf.line_to( pt[0], pt[1] ) }
+    pdf.stroke
+
+    x1, y1 = [p[0][0], p[0][1]]
+    x2, y2 = [p[-1][0], p[-1][1]]
+    pdf_draw_arrow(pdf, opts, x1, y1, x2, y2)
+  end
+
+  def pdf_draw_simple(pdf, opts)
+    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)
+    pdf.move_to(x1, y1)
+    pdf.line_to(x2, y2).stroke
+    pdf_draw_arrow(pdf, opts, x1, y1, x2, y2)
+    if @type == LOCKED_DOOR
+      v = [ (x2-x1)*0.25, (y2-y1)*0.25 ]
+      m = [ (x2+x1)/2, (y2+y1)/2 ]
+      x1, y1 = [m[0] + v[1], m[1] - v[0]]
+      x2, y2 = [m[0] - v[1], m[1] + v[0]]
+      pdf.move_to(x1, y1)
+      pdf.line_to(x2, y2).stroke
+    end
+  end
+
+  def pdf_draw(pdf, opts)
+    # pdf_draw_exit_text(pdf, opts)
+    if @type == SPECIAL
+      s = PDF::Writer::StrokeStyle.new(2, :dash => { 
+					 :pattern => [2],
+					 :phase => [1]
+				       } ) 
+    else
+      s = PDF::Writer::StrokeStyle.new(2,
+				       :cap => :butt, 
+				       :join => :miter, 
+				       :dash => PDF::Writer::StrokeStyle::SOLID_LINE )
+    end
+    pdf.stroke_style( s )
+    pdf.stroke_color  Color::RGB::Black
+    pdf.fill_color    Color::RGB::White
+    if @pts.size > 0
+      pdf_draw_complex(pdf, opts)
+    else
+      pdf_draw_simple(pdf, opts)
+    end
+  end
+end
+
+
+class FXRoom
+  def pdf_corner( pdf, opts, c, idx = nil )
+    x, y = _corner(c, idx)
+    y = -y
+
+    ww = opts['ww']
+    hh = opts['hh']
+    w = opts['w']
+    h = opts['h']
+
+    ry = opts['height'] - @y
+    x = @x * ww + opts['ws_2'] + opts['margin_2'] + x * w
+    y = ry * hh + opts['hs_2'] + h + opts['margin_2'] + y * h
+    return [x, y]
+  end
+
+
+  def pdf_draw_box( pdf, opts )
+    x = @x * opts['ww'] + opts['ws_2'] + opts['margin_2']
+    y = (opts['height'] - @y) * opts['hh'] + opts['hs_2'] + opts['margin_2']
+
+    s = PDF::Writer::StrokeStyle::DEFAULT
+    pdf.stroke_style( s )
+
+    if @darkness
+      pdf.fill_color( Color::RGB::Gray )
+    else
+      pdf.fill_color( Color::RGB::White )
+    end
+
+    pdf.rectangle(x, y, opts['w'], opts['h']).fill_stroke
+  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
+    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
+  end
+
+  def pdf_draw( pdf, opts, idx )
+    pdf_draw_box( pdf, opts )
+    pdf_draw_name( pdf, opts )
+  end
+end
+
+
+
+class FXPage
+
+  def pdf_draw_grid(pdf, opts, w, h )
+    (0...w).each { |xx|
+      (0...h).each { |yy|
+	x = xx * opts['ww'] + opts['ws_2'] + opts['margin_2']
+	y = yy * opts['hh'] + opts['hs_2'] + opts['margin_2']
+	pdf.rectangle(x, y, opts['w'], opts['h']).stroke
+      }
+    }
+  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 )
+    return if not @name or @name == ''
+    pdf.text( @name,
+	     :font_size => 16,
+	     :justification => :center
+	     )
+  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
+      pdf.rotate_axis(90.0)
+      pdf.translate_axis( 0, -pdf.page_width )
+    end
+
+    # 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 )
+
+    # 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) }
+  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
+      # 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)
+    }
+
+    # Restore original viewing page
+    @page = old_page
+    create_pathmap
+  end
+
+  def pdf_export(pdffile = Dir::tmpdir + "/ifmap.pdf", printer = nil)
+
+    paper = 'LETTER'
+    if printer
+      case printer.mediasize
+      when FXPrinter::MEDIA_LEGAL
+	paper = 'LEGAL'
+      when FXPrinter::MEDIA_A4
+	paper = 'A4'
+      when FXPrinter::MEDIA_ENVELOPE
+	paper = 'ENVELOPE'
+      when FXPrinter::MEDIA_CUSTOM
+	raise "Sorry, custom paper not supported"
+      end
+    end
+
+    # Open a new PDF writer with paper selected
+    pdf = PDF::Writer.new :paper => paper
+
+
+    pdf_options = @options.dup
+    pdf_options.merge!( 
+		       { 
+			 'ww'       => PDF_ROOM_WIDTH  + PDF_ROOM_WS,
+			 'hh'       => PDF_ROOM_HEIGHT + PDF_ROOM_HS,
+			 'w'        => PDF_ROOM_WIDTH,
+			 'h'        => PDF_ROOM_HEIGHT,
+			 'ws'       => PDF_ROOM_WS,
+			 'hs'       => PDF_ROOM_HS,
+			 'ws_2'     => PDF_ROOM_WS / 2.0,
+			 'hs_2'     => PDF_ROOM_HS / 2.0,
+			 'margin'   => PDF_MARGIN,
+			 'margin_2' => PDF_MARGIN / 2.0,
+			 'width'    => @width  - 1,
+			 'height'   => @height - 1,
+		       }
+		       )
+
+
+    begin
+      # See if it is possible to pack several map sections (pages) into
+      # a single print page.
+      # pack_sections
+      pdf_draw_pages(pdf, pdf_options)
+      p "Saving pdf to '#{pdffile}'..."
+      pdf.save_as(pdffile)
+    rescue => e
+      p e
+      p e.backtrace
+      # raise e
+    end
+  end
+end

data/lib/IFMapper/Page.rb

@@ -0,0 +1,158 @@
+
+
+require 'IFMapper/Connection'
+require 'IFMapper/Room'
+
+class Page
+  attr_accessor :rooms
+  attr_accessor :connections
+  attr_accessor :name
+
+  def marshal_load(v)
+    @rooms       = v[0]
+    @connections = v[1]
+    @name        = v[2]
+  end
+
+  def marshal_dump
+    return [ @rooms, @connections, @name ]
+  end
+
+  #
+  # Return the number of rooms in width and height for this page
+  #
+  def rooms_width_height
+    minXY, maxXY = min_max_rooms
+    return [ 
+      maxXY[0] - minXY[0] + 1,
+      maxXY[1] - minXY[1] + 1
+    ]
+  end
+
+  #
+  # Return the min and max coordinates of all rooms in page
+  #
+  def min_max_rooms
+    return [0, 0] if @rooms.empty?
+    
+    minXY = [ @rooms[0].x, @rooms[0].y ]
+    maxXY = minXY.dup
+    @rooms.each { |r|
+      minXY[0] = r.x if r.x < minXY[0]
+      minXY[1] = r.y if r.y < minXY[1]
+      maxXY[0] = r.x if r.x > maxXY[0]
+      maxXY[1] = r.y if r.y > maxXY[1]
+    }
+    return [ minXY, maxXY ]
+  end
+
+
+  def delete_connection(c)
+    a = c.roomA
+    if a
+      e = a.exits.index(c)
+      a[e] = nil if e
+    end
+    b = c.roomB
+    if b
+      e = b.exits.rindex(c)
+      b[e] = nil if e
+    end
+    @connections.delete(c)
+  end
+
+  def delete_connection_at( idx )
+    c = @connections[idx]
+
+    a = c.roomA
+    if a
+      e = a.exits.index(c)
+      a[e] = nil if e
+    end
+    b = c.roomB
+    if b
+      e = b.exits.rindex(c)
+      b[e] = nil if e
+    end
+    @connections.delete_at(idx)
+  end
+
+  def _new_connection(c, roomA, exitA, roomB, exitB)
+    exitA = roomA.exit_to(roomB) if not exitA
+    if not exitA
+      err = <<"EOF"
+No exit given or guessed to connect: 
+      Room #{roomA} (#{roomA.x}, #{roomA.y})
+      Room #{roomB} (#{roomB.x}, #{roomB.y})
+EOF
+      raise err
+    end
+
+    if roomA[exitA]
+      if not @connections.include?(roomA[exitA])
+	raise "room exit filled but not in page"
+      end
+      raise "room exit #{exitA} for #{roomA} is filled" 
+    end
+
+    roomA[exitA] = c
+
+    if roomB and not exitB
+      dx, dy = Room::DIR_TO_VECTOR[exitA]
+      x = roomA.x + dx
+      y = roomA.y + dy
+      if roomB.x == x and roomB.y == y
+	exitB = (exitA + 4) % 8 
+      else
+	dx = x - roomB.x
+	dy = y - roomB.y
+	exitB = roomB.vector_to_dir(dx, dy)
+      end
+    end
+
+    if roomB and roomB[exitB] and roomB[exitB] != c
+      raise "room exit #{exitB} for #{roomB} is filled" 
+    end
+    roomB[exitB] = c if roomB
+
+    @connections.push( c )
+    return c
+  end
+
+  def new_connection( roomA, exitA, roomB, exitB = nil )
+    c = Connection.new( roomA, roomB )
+    _new_connection(c, roomA, exitA, roomB, exitB )
+  end
+
+  def delete_room_at(idx)
+    r = @rooms[idx]
+    r.exits.each { |e|
+      next if not e
+      delete_connection(e)
+    }
+    @rooms.delete_at(idx)
+  end
+
+  def delete_room(r)
+    r.exits.each { |e|
+      next if not e
+      delete_connection(e)
+    }
+    @rooms.delete(r)
+  end
+
+  def _new_room( r, x, y )
+    @rooms.push(r)
+    return r
+  end
+
+  def new_room( x, y )
+    r = Room.new( x, y, 'New Location' )
+    return _new_room(r, x, y)
+  end
+
+  def initialize()
+    @rooms       = []
+    @connections = []
+  end
+end