ifmapper 0.5

data/lib/IFMapper/FXConnectionDialogBox.rb

@@ -0,0 +1,126 @@
+
+#
+# Class used to display a connection dialog box
+#
+class FXConnectionDialogBox < FXDialogBox
+
+  TYPE_TEXT = [
+    'Free',
+    'Locked',
+    'Special',
+  ]
+
+  DIR_TEXT = [
+    'Both',
+    'A to B',
+    'B to A',
+  ]
+
+  EXIT_TEXT = [ 
+    'None',
+    'Up',
+    'Down',
+    'In',
+    'Out',
+  ]
+
+  attr_writer :map
+
+  def copy_to()
+    @conn.dir       = @dir.currentNo
+    @conn.type      = @type.currentNo
+    @conn.exitAtext = @exitA.currentNo
+    @conn.exitBtext = @exitB.currentNo
+
+    @map.draw
+  end
+
+
+  def copy_from(conn)
+    title = conn.to_s
+    self.title = title
+
+    @dir.currentNo   = conn.dir
+    @type.currentNo  = conn.type || 0
+    @exitA.currentNo = conn.exitAtext
+    @exitB.currentNo = conn.exitBtext
+    @conn = conn
+
+    if @map.navigation
+      @dir.disable
+      @type.disable
+      @exitA.disable
+      @exitB.disable
+    else
+      @dir.enable
+      @type.enable
+      @exitA.enable
+      @exitB.enable
+    end
+  end
+
+  def initialize(map, conn, event = nil)
+    pos = [40, 40]
+    if event
+      pos  = [ event.last_x, event.last_y ]
+    end
+    maxW = map.window.width  - 390
+    maxH = map.window.height - 300
+    pos[0] = maxW if pos[0] > maxW
+    pos[1] = maxH if pos[1] > maxH
+    
+    decor = DECOR_TITLE|DECOR_BORDER|DECOR_CLOSE
+    super( map.window, '', decor, pos[0], pos[1], 0, 0 )
+    mainFrame = FXVerticalFrame.new(self,
+				    FRAME_SUNKEN|FRAME_THICK|
+				    LAYOUT_FILL_X|LAYOUT_FILL_Y)
+
+    frame = FXHorizontalFrame.new(mainFrame, LAYOUT_SIDE_TOP|LAYOUT_FILL_X)
+
+    FXLabel.new(frame, "Connection Type: ", nil, 0, LAYOUT_FILL_X)
+    pane = FXPopup.new(self)
+    TYPE_TEXT.each { |t|
+      FXOption.new(pane, t, nil, nil, 0, JUSTIFY_HZ_APART|ICON_AFTER_TEXT)
+    }
+    @type = FXOptionMenu.new(frame, pane, FRAME_RAISED|FRAME_THICK|
+			     JUSTIFY_HZ_APART|ICON_AFTER_TEXT|
+			     LAYOUT_CENTER_X|LAYOUT_CENTER_Y)
+
+
+    FXLabel.new(frame, "Direction: ", nil, 0, LAYOUT_FILL_X)
+    pane = FXPopup.new(self)
+    DIR_TEXT.each { |t|
+      FXOption.new(pane, t, nil, nil, 0, JUSTIFY_HZ_APART|ICON_AFTER_TEXT)
+    }
+    @dir = FXOptionMenu.new(frame, pane, FRAME_RAISED|FRAME_THICK|
+			    JUSTIFY_HZ_APART|ICON_AFTER_TEXT|
+			    LAYOUT_CENTER_X|LAYOUT_CENTER_Y)
+
+    frame = FXHorizontalFrame.new(mainFrame, LAYOUT_SIDE_TOP|LAYOUT_FILL_X)
+    FXLabel.new(frame, "Exit A Text: ", nil, 0, LAYOUT_FILL_X)
+    pane = FXPopup.new(self)
+    EXIT_TEXT.each { |t|
+      FXOption.new(pane, t, nil, nil, 0, JUSTIFY_HZ_APART|ICON_AFTER_TEXT)
+    }
+    @exitA = FXOptionMenu.new(frame, pane, FRAME_RAISED|FRAME_THICK|
+			      JUSTIFY_HZ_APART|ICON_AFTER_TEXT|
+			      LAYOUT_CENTER_X|LAYOUT_CENTER_Y)
+    FXLabel.new(frame, "Exit B Text: ", nil, 0, LAYOUT_FILL_X)
+    pane = FXPopup.new(self)
+    EXIT_TEXT.each { |t|
+      FXOption.new(pane, t, nil, nil, 0, JUSTIFY_HZ_APART|ICON_AFTER_TEXT)
+    }
+    @exitB = FXOptionMenu.new(frame, pane, FRAME_RAISED|FRAME_THICK|
+			      JUSTIFY_HZ_APART|ICON_AFTER_TEXT|
+			      LAYOUT_CENTER_X|LAYOUT_CENTER_Y)
+
+    @dir.connect(SEL_COMMAND) { copy_to() }
+    @type.connect(SEL_COMMAND) { copy_to()}
+    @exitA.connect(SEL_COMMAND) { copy_to() }
+    @exitB.connect(SEL_COMMAND) { copy_to() }
+    @map = map
+
+    # We need to create the dialog box first, so we can use select text.
+    create
+  end
+end

data/lib/IFMapper/FXMap.rb

@@ -0,0 +1,1614 @@
+#!/usr/bin/env ruby
+
+
+require 'IFMapper/Map'
+require 'IFMapper/FXPage'
+require 'IFMapper/FXMapDialogBox'
+require 'IFMapper/FXPageDialogBox'
+
+
+class FXMap < Map
+  FILE_FORMAT_VERSION = 1  # Upgrade this if incompatible changes are made
+                           # in the class so that file loading of old files can still
+                           # be checked against.
+
+  attr_reader   :zoom        # Current zooming factor
+  attr_accessor :filename    # Filename of current map (if any)
+  attr_reader   :modified    # Was map modified since being loaded?
+  attr_accessor :navigation  # Map is navigation mode (no new nodes can be created)
+  attr_accessor :options     # Map options
+  attr_reader   :window      # Fox Window for this map
+  attr          :version     # file format version
+
+  # pmap is a path map (a matrix or grid used for path finding).  
+  # Rooms and paths are recorded there.  Path finding is needed 
+  # to draw complex connections (ie. those that are farther than one square)
+  # We now also use this for selecting of stuff, particularly complex paths.
+  attr          :pmap
+
+  @@win = nil
+  
+  @@cursor_arrow = nil
+  @@cursor_cross = nil
+  @@cursor_updown = nil
+
+
+  def _changed
+    create_pathmap
+    update_title
+    draw
+  end
+
+  def page=(x)
+    super
+    @complexConnection = false
+    create_pathmap
+    update_title
+  end
+
+
+  def previous_page
+    self.page = @page - 1
+    _changed
+  end
+
+  def next_page
+    self.page = @page + 1
+    _changed
+  end
+
+  def modified=(x)
+    @modified = true
+    _changed
+  end
+
+  def rename_page
+    @pages[@page].properties(self)
+    modified = true
+  end
+
+  def delete_page
+    w = FXWarningBox.new(@window, "Are you sure you want to delete this page?")
+    return if w.execute == 0
+
+    delete_page_at(@page)
+    modified = true
+  end
+
+  def new_page 
+    @pages.push( FXPage.new )
+    @page = @pages.size - 1
+  end
+
+  #
+  # A simple debugging function that will spit out the path map with a 
+  # very simple ascii representation.
+  #
+  def dump_pathmap
+    s = ' ' * @width + "\n"
+    m = s * @height
+    (0...@width).each { |x|
+      (0...@height).each { |y|
+	loc = y * (@width+1) + x
+	if @pmap[x][y].kind_of?(Connection)
+	  m[loc] = '-'
+	elsif @pmap[x][y].kind_of?(Room)
+	  m[loc] = 'R'
+	end
+      }
+    }
+    puts m
+  end
+
+  #
+  # Reinitialize the pathmap to an empty matrix
+  # 
+  def empty_pathmap
+    # First, create an empty grid of width x height
+    @pmap = Array.new(@width)
+    (0...@width).each { |x|
+      @pmap[x] = Array.new(@height)
+    }
+    return pmap
+  end
+
+  #
+  # Recreate the pathmap based on rooms and connections
+  # This routine is used on loading a new map.
+  #
+  def create_pathmap
+    # First, create an empty grid of width x height
+    empty_pathmap   # Hmm... needed?  Probably not.
+    # Then, fill it in with all rooms...
+    @pages[@page].rooms.each { |r| @pmap[r.x][r.y] = r }
+    # And following, add all paths
+    @pages[@page].connections.each { |c| path_find(c) }
+  end
+
+  #
+  # Given a connection, clean its path from path map.
+  #
+  def clean_path(c)
+    c.gpts.each { |p| @pmap[p[0]][p[1]] = nil if @pmap[p[0]][p[1]] == c }
+  end
+
+  #
+  # Remove a connection from map, since path creation failed.
+  #
+  def remove_connection(c)
+    clean_path(c)
+    c.failed = true
+    status "Path for connection #{c} is blocked."
+  end
+
+  # Given a connection, create the path for it, if not a simple
+  # connection.  Also, add the paths to pathmap.
+  def path_find(c)
+    unless c.complex?
+      c.pts = c.gpts = []
+      c.failed = false
+      return true
+    end
+
+    # Complex path... Generate points.
+    a = c.roomA
+    b = c.roomB
+
+    # First, check the neighboring starting/ending nodes in grid
+    # are empty.  If not, we need to abort and remove path from list.
+    dirA = a.exits.index(c)
+    raise "connection not found #{c} at #{a}" unless dirA
+
+    dirB = b.exits.rindex(c)
+    raise "connection not found #{c} at #{b}" unless dirB
+
+    vA = FXRoom::DIR_TO_VECTOR[dirA]
+    vB = FXRoom::DIR_TO_VECTOR[dirB]
+
+    pA = [ a.x + vA[0], a.y + vA[1] ]
+    pB = [ b.x + vB[0], b.y + vB[1] ]
+
+    c.gpts = []
+    c.pts  = []
+
+    # Check for the special case of looping path (path that begins and
+    # returns to same exit)
+    if a == b and dirA == dirB
+      pt = a.corner(c, 1, dirA)
+      n  = 1.0 / Math.sqrt(vA[0] * vA[0] + vA[1] * vA[1])
+      vA = [ vA[0] * n, vA[1] * n ]
+      c.pts.push( [ pt[0], pt[1] ] )
+      pA = [ pt[0] + vA[0] * 20, pt[1] + vA[1] * 20 ]
+      c.pts.push( [pA[0], pA[1]] )
+      pB = [ pA[0] + vA[1] * 20, pA[1] - vA[0] * 20 ]
+      c.pts.push( [pB[0], pB[1]] )
+      pC = [ pB[0] - vA[0] * 20, pB[1] - vA[1] * 20 ]
+      c.pts.push( [pC[0], pC[1]] )
+      c.dir = Connection::AtoB
+      return true
+    end
+
+
+    if pA[0] < 0 or pA[0] >= @width or
+	pB[0] < 0 or pB[0] >= @width or
+	pA[1] < 0 or pA[1] >= @height or
+	pB[1] < 0 or pB[1] >= @height
+      remove_connection(c)
+      return false
+    end
+
+    c.failed = false
+
+    # We do two tries on path finding.
+    # On first attempt, we try to avoid both rooms and paths.
+    # That is, we always try to have no paths crossing each other.
+    # 
+    # If this fails, we try a second time, but we try to avoid just
+    # rooms.  In this second attempt, paths are allowed to intercross.
+    #
+    pt = pA.dup
+    2.times { |try|
+      c.gpts = []
+
+      if try == 0
+	next if @pmap[pA[0]][pA[1]] or @pmap[pB[0]][pB[1]] # try again
+      else
+	if @pmap[pA[0]][pA[1]].kind_of?(Room) or 
+	    @pmap[pB[0]][pB[1]].kind_of?(Room)
+	  remove_connection(c)
+	  return false
+	end
+      end
+
+      # Okay, now we begin the real path algorithm...
+      # Add first point...
+      add_path_pt(c, pA[0], pA[1])
+      
+      pt = pA.dup
+      
+      # Okay, now we begin a simple A* path algorithm. 
+      while pt[0] != pB[0] or pt[1] != pB[1]
+	# From point pt, get a list of free nodes, by looking all around it.
+	pts = [] 
+	FXRoom::DIR_TO_VECTOR.each_value { |d|
+	  n = pt.dup
+	  n[0] += d[0]
+	  n[1] += d[1]
+	  # Don't add point to list if we go out of map
+	  if n[0] < 0 or n[0] >= @width or
+	      n[1] < 0 or n[1] >= @height
+	    next
+	  end
+	  
+	  # Now, check if pmap is an empty node.
+	  if try == 1
+	    next if @pmap[n[0]][n[1]].kind_of?(Room) or
+	      @pmap[n[0]][n[1]] == c
+	  else
+	    next if @pmap[n[0]][n[1]]
+	  end
+	  
+	  # Ok, we do have an empty node.  Add to list.
+	  pts.push(n)
+	}
+
+	break if pts.empty?
+
+	# Okay, from all possible nodes, calculate best one, using
+	# the formula:
+	#   F = G + H
+	# where G = movement cost to move from point to other point
+	#           (10 or 14, depending if move is straight or diagonal)
+	#       H = cost of square to shorten distance to destination.
+	#           (heuristic, in this case using Manhattan distance)
+	# Next move is the grid node with lowest F cost.
+	
+	f = []
+	pts.each { |x|
+	  dx = x[0] - pt[0]
+	  dy = x[1] - pt[1]
+	  g = 10   # straight move G cost = 10 (ie. prefer straight moves)
+	  if dx.abs + dy.abs > 1
+	    g = 14 # diagonal move G cost = 14
+	  end
+	  
+	  dx = pB[0] - x[0]
+	  dy = pB[1] - x[1]
+	  h = dx * dx + dy * dy
+
+	  f.push( h + g )
+	}
+	
+	idx = f.index(f.min)
+	pt  = pts[idx]
+	add_path_pt(c, pt[0], pt[1])
+      end # while
+
+
+      # Are we really there?
+      if pt[0] != pB[0] or pt[1] != pB[1]
+	# No, we must have failed...
+	clean_path(c)
+	c.gpts = []
+	next  # go for next try
+      else
+	break
+      end
+    }
+
+    # If still not there, we cannot connect path, exit gracefully
+    if pt[0] != pB[0] or pt[1] != pB[1]
+      # If on second try, remove connection as invalid.
+      remove_connection(c)
+      return false
+    end
+
+
+    # Okay, we have a valid path. 
+    # Create real path in display coordinates now...
+    # Start with a's corner
+    pt = a.corner(c, 1, dirA)
+    c.pts.push( [ pt[0], pt[1] ] )
+    # Then, add each grid point we calculated
+    c.gpts.each { |pt| 
+      x = pt[0] * WW + WW / 2
+      y = pt[1] * HH + HH / 2
+      c.pts.push([x, y])
+    }
+    # And end with b's corner
+    pt = b.corner(c, 1, dirB)
+    c.failed = false
+    return c.pts.push([pt[0], pt[1]])
+  end
+
+  #
+  # Add a new path point to a connection
+  #
+  def add_path_pt( c, x, y )
+    @pmap[x][y] = c
+    c.gpts.push([x, y])
+  end
+
+  #
+  # Used for loading class with Marshal
+  #
+  def marshal_load(variables)
+#     if variables[1].kind_of?(Map)
+#       # old format
+#       @zoom       = variables[0]
+#       tmpmap      = variables[1]
+#       copy(tmpmap)
+#       @navigation = variables[2]
+#       @options    = variables[3] if variables[3]
+#     else
+      @zoom       = variables.shift
+      @navigation = variables.shift
+      @options    = variables.shift
+      super
+#     end
+    @modified   = false
+  end
+
+  #
+  # Used for saving class with Marshal
+  #
+  def marshal_dump
+    [ @zoom, @navigation, @options ] + super 
+  end
+
+  #
+  # Used to copy relevant data from one (temporary) map to another
+  #
+  def copy(b)
+    super(b)
+    if b.kind_of?(FXMap)
+      @options  = b.options if b.options
+      @filename = b.filename
+      self.zoom = b.zoom
+    end
+  end
+
+  #
+  # Function used to add a new room. x and y are absolute pixel positions
+  # in canvas.
+  #
+  def new_xy_room(x, y)
+    @modified = true
+    x = x / WW
+    y = y / HH
+    r = @pages[@page].new_room(x, y)
+    @pmap[x][y] = r
+
+    buf = FXMapperWindow::copy_buffer()
+    r.copy(buf) if buf
+    r.selected = true
+
+    
+    if @options['Edit on Creation']
+       if not r.modal_properties(self)
+	 @pages[@page].delete_room(r)
+	 @pmap[x][y] = nil
+	 return nil
+       end
+    end
+
+    return r
+  end
+
+
+  # Given a canvas (mouse) x/y position, return:
+  #
+  # false - arrow click
+  # true  - room  click
+  #
+  def click_type(x, y)
+    x = (x % WW).to_i
+    y = (y % HH).to_i
+
+    if x >= WS_2 and y >= HS_2 and
+	x <= (W + WS_2) and y <= (H + HS_2)
+      return true
+    else
+      return false
+    end
+  end
+
+  # Given an x and y canvas position, return room object, 
+  # complex connection or nil
+  def to_room(x,y)
+    xx = x / WW
+    yy = y / HH
+    return @pmap[xx][yy]
+  end
+
+  # Given a mouse click x/y position, return object(s) if any or nil
+  def to_object(x, y)
+
+    exitA = get_quadrant(x, y)
+    unless exitA
+      # Not in arrow section, return element based on pmap
+      # can be a room or complex arrow connection.
+      xx = x / WW
+      yy = y / HH
+      return nil if xx >= @width or yy >= @height
+      return @pmap[xx][yy]
+    else
+      # Possible arrow
+      @pages[@page].connections.each { |c|
+	a = c.roomA
+	b = c.roomB
+	next if not b  # Complex connection in progress
+
+	if c.gpts.size > 0
+	  [a, b].each { |r|
+	    next if not r
+	    dir = r.exits.index(c)
+	    x1, y1 = r.corner(c, 1, dir)
+	    v = FXRoom::DIR_TO_VECTOR[dir]
+	    x2 = x1 + v[0] * WS
+	    y2 = y1 + v[1] * HS
+	    
+	    if x1 == x2
+	      x1 -= W / 2
+	      x2 += W / 2
+	    end
+	    if y1 == y2
+	      y1 -= H / 2
+	      y2 += H / 2
+	    end
+	    if x >= x1 and x <= x2 and
+		y >= y1 and y < y2
+	      return c
+	    end
+	  }
+	else
+	  x1, y1 = a.corner(c, 1, a.exits.index(c))
+	  x2, y2 = b.corner(c, 1, b.exits.rindex(c))
+	  x1, x2 = x2, x1 if x2 < x1
+	  y1, y2 = y2, y1 if y2 < y1
+	  if x1 == x2
+	    x1 -= W / 2
+	    x2 += W / 2
+	  end
+	  if y1 == y2
+	    y1 -= H / 2
+	    y2 += H / 2
+	  end
+	  if x >= x1 and x <= x2 and
+	      y >= y1 and y < y2
+	    return c
+	  end
+	end
+      }
+
+      # Then, get "rooms" being connected to check if we get
+      # a complex connection instead.
+      roomA, roomB, a, b = quadrant_to_rooms( exitA, x, y )
+      return roomA if roomA.kind_of?(Connection)
+      return roomB if roomB.kind_of?(Connection)
+    end
+
+    return nil
+  end
+
+  def update_title
+    title = @name.dup
+    if @navigation
+      title << "     [Read Only]"
+    end
+    title << "      Zoom: %.3f" % @zoom
+    title << "      Page #{@page+1} of #{@pages.size}"
+    title << "      #{@pages[@page].name}"  
+    @window.title = title
+  end
+
+  # Change zoom factor of map.  Rebuild fonts and canvas sizes.
+  def zoom=(value)
+    @zoom = ("%.2f" % value).to_f
+    # Create the font
+    fontsize = (11 * @zoom).to_i
+
+    if @window
+      @font = FXFont.new(@window.getApp, @options['Font Text'], fontsize)
+      @font.create
+
+      @objfont = FXFont.new(@window.getApp, @options['Font Objects'], 
+			    (fontsize * 0.75).to_i)
+      @objfont.create
+
+      width  = (WW * @width * @zoom).to_i
+      height = (HH * @height * @zoom).to_i
+      @canvas.width  = width
+      @canvas.height = height
+
+      # Then, create an off-screen image with that same size for double
+      # buffering
+      @image.destroy
+      @image = FXBMPImage.new(@window.getApp, nil, IMAGE_SHMI|IMAGE_SHMP, 
+			      width, height)
+      @image.create
+      update_title
+    end
+
+  end
+
+  # Given a mouse x/y position to WS/HS, return an index 
+  # indicating what quadrant it belongs to.
+  def get_quadrant(ax, ay)
+    # First get relative x/y position
+    x = ax % WW
+    y = ay % HH
+
+    quadrant = nil
+    if x < WS_2
+      #left
+      if y < HS_2
+	# top
+	quadrant = 7
+      elsif y > H + HS_2
+	# bottom
+	quadrant = 5
+      else
+	# center
+	quadrant = 6
+      end
+    elsif x > W + WS_2
+      # right
+      if y < HS_2
+	# top
+	quadrant = 1
+      elsif y > H + HS_2
+	# bottom
+	quadrant = 3
+      else
+	# center
+	quadrant = 2
+      end
+    else
+      #center
+      if y < HS_2
+	# top
+	quadrant = 0
+      elsif y > H + HS_2
+	# bottom
+	quadrant = 4
+      else
+	# center
+	quadrant = nil
+      end
+    end
+
+
+    return quadrant
+  end
+
+  # Given an x,y absolute position corresponding to a connection,
+  # return connected rooms (if any).
+  def quadrant_to_rooms( q, x, y )
+    maxX = @width  * WW
+    maxY = @height * HH
+
+    # First check if user tried adding a connection
+    # at the edges of the map.  If so, return empty stuff.
+    if  x < WS_2 or y < HS_2 or
+	x > maxX - WS_2 or y > maxY - HS_2
+      return [nil, nil, nil, nil]
+    end
+
+    x1 = x2 = x
+    y1 = y2 = y
+
+    case q
+    when 0, 4
+      y1 -= HS
+      y2 += HS
+    when 1, 5
+      x1 -= WS
+      x2 += WS
+      y1 += HS
+      y2 -= HS
+    when 2, 6
+      x1 -= WS
+      x2 += WS
+    when 3, 7 
+      x1 -= WS
+      y1 -= HS
+      x2 += WS
+      y2 += HS
+    end
+
+    case q
+      when 0, 5, 6, 7
+      x1, x2 = x2, x1
+      y1, y2 = y2, y1
+    end
+
+    roomA = to_room(x1, y1)
+    roomB = to_room(x2, y2)
+    # Oops, user tried to create rooms where we already
+    # have a complex connection.  Don't create anything, then.
+    if roomA.kind_of?(Connection) or roomB.kind_of?(Connection)
+      return [roomA, roomB, nil, nil]
+    end
+
+    return [roomA, roomB, [x1, y1], [x2, y2]]
+  end
+
+  #
+  # Add a new complex connection (or its first point)
+  #
+  def new_complex_connection( x, y )
+    exitA = get_quadrant(x, y)
+    unless exitA
+      raise "not a connection"
+    end
+    roomA, roomB, a, b = quadrant_to_rooms( exitA, x, y )
+    return unless a and roomA # User click outside map or not near room
+
+    if @complexConnection.kind_of?(TrueClass)
+      @complexConnection = [roomA, exitA]
+      c = new_connection( roomA, exitA, nil )
+      status "Click on other room exit in complex connection."
+    else
+      @pages[@page].delete_connection_at(-1)
+      c = new_connection( @complexConnection[0], 
+			 @complexConnection[1], roomA, exitA )
+      if path_find(c)  # Do A* path finding to connect both exits
+	@modified = true
+	status "Complex connection done."
+      else
+	@pages[@page].delete_connection_at(-1)
+      end
+      draw
+      @complexConnection = nil
+    end
+  end
+
+  #
+  # Add a new room connection among contiguous rooms.
+  #
+  def new_xy_connection( x, y )
+    exitA = get_quadrant(x, y)
+    unless exitA
+      raise "not a connection"
+    end
+
+    # Then, get rooms being connected
+    roomA, roomB, a, b = quadrant_to_rooms( exitA, x, y )
+    return unless a # User click outside map
+
+    if @options['Create on Connection']
+      unless roomA
+	roomA = new_xy_room( a[0], a[1] )
+      end
+      
+      unless roomB
+	roomB = new_xy_room( b[0], b[1] )
+      end
+    end
+
+    return nil unless roomA and roomB
+
+    if roomA == roomB
+      raise "error: same room connection"
+    end
+
+    @modified = true
+    if roomA and exitA
+      # get old connection
+      if roomA[exitA]
+	c = roomA[exitA]
+	delete_connection(c) if c.roomB == nil
+      end
+      exitB = (exitA + 4) % 8
+      if roomB[exitB]
+	c = roomB[exitB]
+	delete_connection(c) if c.roomB == nil
+      end
+    end
+
+    new_connection( roomA, exitA, roomB )
+  end
+
+  #
+  # Handle mouse button double clicks in canvas
+  #
+  def double_click_cb(selection, event)
+    return unless selection
+    if selection.kind_of?(FXRoom) or selection.kind_of?(FXConnection)
+      selection.properties( self, event )
+    end
+  end
+
+  ZOOM_SEQUENCE = [
+    0.4,
+    0.5,
+    0.6,
+    0.7,
+    0.8,
+    0.9,
+    1.0,
+    1.1,
+    1.2,
+  ]
+
+  # Self-explanatory.
+  def zoom_out
+    if @zoom > 0.25
+      self.zoom -= 0.1
+    end
+  end
+
+  # Self-explanatory.
+  def zoom_in
+    if @zoom < 1.25
+      self.zoom += 0.1
+    end
+  end
+
+  # Spit out a new message to the status line.
+  def status(msg)
+    mw  = @window.parent.parent
+    statusbar = mw.children.find() { |x| x.kind_of?(FXStatusBar) }
+    s = statusbar.statusLine
+    s.normalText = s.text = msg
+  end
+
+  #
+  # Show some help status in status line based on cursor position
+  #
+  def help_cb(sender, sel, event)
+    return if @complexConnection
+    x = (event.last_x / @zoom).to_i
+    y = (event.last_y / @zoom).to_i
+
+    sel = to_object(x, y)
+    if sel
+      @canvas.defaultCursor = @@cursor_arrow
+      if sel.kind_of?(Room)
+	status "Click to select and move.  Double click to edit room."
+      elsif sel.kind_of?(Connection)
+	status "Click to change direction of connection."
+      end
+    else
+      if click_type(x, y)
+	@canvas.defaultCursor = @@cursor_cross
+	status "Click to create new room."
+      else
+	q = get_quadrant(x, y)
+	if q == 0 or q == 4
+	  @canvas.defaultCursor = @@cursor_updown
+	elsif q == 2 or q == 6
+	  @canvas.defaultCursor = @@cursor_leftright
+	else
+	  @canvas.defaultCursor = @@cursor_arrow
+	end
+	status "Click to create new connection."
+      end
+    end
+  end
+
+  #
+  # zoom in/out based on mousewheel, keeping position relative
+  # to cursor position
+  #
+  def mousewheel_cb(sender, sel, event)
+    pos = @scrollwindow.position
+    pos = [ pos[0] / @zoom, pos[1] / @zoom ]
+    x = (event.last_x / @zoom).to_i
+    y = (event.last_y / @zoom).to_i
+    case event.code
+    when -120
+      zoom_out
+      # pos[0] -= x / 2
+      # pos[1] -= y / 2
+      pos = [ pos[0] * @zoom, pos[1] * @zoom ]
+      @scrollwindow.setPosition(pos[0], pos[1])
+    when 120
+      zoom_in
+
+      #pos[0] = -x # * @zoom * 2
+      #pos[1] = -y # * @zoom * 2
+
+      # pos = [ pos[0], pos[1] ]
+      # pos = [ pos[0] * @zoom, pos[1] * @zoom ]
+      @scrollwindow.setPosition(pos[0], pos[1])
+    end
+#     x = (x * @zoom).to_i
+#     y = (y * @zoom).to_i
+#     if x > @canvas.width
+#       x = @canvas.width
+#     end
+#     if y > @canvas.height
+#       y = @canvas.height
+#     end
+
+#     pos = [ pos[0] - x, pos[1] - y ]
+#     p "SET: #{pos.join(',')}"
+
+#     # @scrollwindow.setPosition(pos[0], pos[1])
+#     p @scrollwindow.position
+    draw
+  end
+
+  #
+  # Handle middle mouse button click in canvas
+  #
+  def mmb_click_cb(server, sel, event)
+    @canvas.grab
+    @dx = @dy = 0
+    @mouseButton = MIDDLEBUTTON
+  end
+
+  #
+  # Select all rooms within (drag) rectangle
+  # TODO: Should add connections too
+  #
+  def select_rectangle(x1, y1, x2, y2)
+    x1, x2 = x2, x1 if x2 < x1
+    y1, y2 = y2, y1 if y2 < y1
+
+    x = x1 * zoom
+    y = y1 * zoom
+    w = x2 - x1
+    h = y2 - y1
+
+    x1 = (x1 / WW).floor
+    y1 = (y1 / HH).floor
+    x2 = (x2 / WW).ceil
+    y2 = (y2 / HH).ceil
+
+    @pages[@page].rooms.each { |r|
+      if r.x >= x1 and r.x <= x2 and
+	  r.y >= y1 and r.y <= y2
+	r.selected = true
+      else
+	r.selected = false
+      end
+    }
+    draw
+    dc = FXDCWindow.new(@canvas)
+    dc.drawRectangle(x, y, w * @zoom, h * @zoom)
+    dc.end
+  end
+
+  #
+  # Handle mouse motion in canvas
+  #
+  def motion_cb(server, sel, event)
+    if @mouseButton == MIDDLEBUTTON
+      @canvas.dragCursor = @@cursor_move
+      pos = @scrollwindow.position
+      dx = event.last_x - event.win_x
+      dy = event.last_y - event.win_y
+      if dx != 0 or dy != 0 and not (dx == @dx and dy == @dy)
+	pos[0] += dx
+	pos[1] += dy
+	@dx = dx
+	@dy = dy
+	@scrollwindow.setPosition(pos[0], pos[1])
+      end
+    elsif @mouseButton == LEFTBUTTON
+      x = (event.last_x / @zoom).to_i
+      y = (event.last_y / @zoom).to_i
+      select_rectangle( @dx, @dy, x, y )
+    else
+      help_cb(server, sel, event)
+    end
+  end
+
+  #
+  # Handle release of middle mouse button
+  #
+  def mmb_release_cb(server, sel, event)
+    if @mouseButton
+      @canvas.ungrab
+      @mouseButton = nil
+      @canvas.dragCursor = @@cursor_arrow
+      draw
+    end
+  end
+
+  #
+  # Clear rooms/connections selected
+  #
+  def clear_selection
+    @pages[@page].rooms.each { |r| r.selected = false }
+    @pages[@page].connections.each { |r| r.selected = false }
+  end
+
+  #
+  # Handle left mouse button click
+  #
+  def lmb_click_cb(sender, sel, event)
+    x = (event.last_x / @zoom).to_i
+    y = (event.last_y / @zoom).to_i
+
+    if event.state & ALTMASK != 0
+      mmb_click_cb(sender, sel, event)
+      return
+    end
+
+    selection = to_object(x, y)
+
+    if event.state & SHIFTMASK != 0
+      @mouseButton = LEFTBUTTON
+      @canvas.grab
+      @dx, @dy = [ x, y ]
+      return if not selection
+    end
+
+
+    if event.click_count == 2
+      double_click_cb(selection, event)
+      return
+    end
+
+    unless selection
+      clear_selection
+
+      # If in navigation mode, we don't allow user to modify map.
+      return if @navigation
+
+      # if we did not select anything, check to see if we
+      # clicked in a room area or connection area.
+      if click_type(x, y)
+	return if @complexConnection
+	# Add a new room
+	roomB = @pages[@page].rooms[-1]
+	roomA = new_xy_room( x, y )
+	if roomB and roomA and @options['Automatic Connection']
+	  # check to see if rooms are next to each other
+	  # if so, try to connect them (assuming there's no connection there
+	  # already).
+	  exitB = roomB.next_to?(roomA)
+	  if exitB and roomB.exits[exitB] == nil
+	    new_connection( roomB, exitB, roomA )
+	  end
+	end
+      else
+	# Add a new connection
+	if @complexConnection
+	  new_complex_connection(x, y)
+	else
+	  # Add a new simple connection (plus rooms if needed)
+	  if event.state & CONTROLMASK != 0
+	    exitA = get_quadrant(x, y)
+	    roomA, roomB, a, b = quadrant_to_rooms( exitA, x, y )
+	    if not roomA
+	      new_xy_connection( x, y )
+	    else
+	      @complexConnection = [roomA, exitA]
+	      new_connection( roomA, exitA, nil )
+	      new_complex_connection( x, y )
+	    end
+	  else
+	    new_xy_connection( x, y )
+	  end
+	end
+      end
+    else
+      if selection.kind_of?(Connection) and selection.selected
+	# Toggle arrow direction
+	selection.toggle_direction
+	draw
+	return
+      else
+	if event.state & SHIFTMASK == 0 and
+	    event.state & CONTROLMASK == 0
+	  clear_selection
+	end
+	# Select the stuff
+	selection.selected = true
+      end
+    end
+    draw(event)
+  end
+
+
+  def close_cb()
+    if @modified
+      dlg = FXDialogBox.new( @window.parent, "Warning", 
+			    DECOR_ALL,
+			    0, 0, 400, 130)
+      # Frame
+      s = FXVerticalFrame.new(dlg,
+			      LAYOUT_SIDE_TOP|LAYOUT_FILL_X)
+
+      f = FXHorizontalFrame.new(s, LAYOUT_SIDE_TOP|LAYOUT_FILL_X|LAYOUT_FILL_Y)
+
+      font = FXFont.new(@window.getApp, "Helvetica", 30)
+      font.create
+      oops = FXLabel.new(f, "!", nil, 0, LAYOUT_SIDE_LEFT|LAYOUT_FILL_X|
+			 LAYOUT_CENTER_Y)
+      oops.frameStyle = FRAME_RAISED|FRAME_THICK
+      oops.baseColor = 'dark grey'
+      oops.textColor = 'red'
+      oops.padLeft = oops.padRight = 15
+      oops.shadowColor = 'black'
+      oops.borderColor = 'white'
+      oops.font = font
+
+      FXLabel.new(f, "\n#{@name} was modified.\n" +
+		  "Should I save the changes before closing?",
+		  nil, 0)
+
+      # Separator
+      FXHorizontalSeparator.new(s,
+				LAYOUT_SIDE_TOP|LAYOUT_FILL_X|SEPARATOR_GROOVE)
+
+      # Bottom buttons
+      buttons = FXHorizontalFrame.new(s,
+				      LAYOUT_SIDE_BOTTOM|FRAME_NONE|
+				      LAYOUT_FILL_X|PACK_UNIFORM_WIDTH)
+      # Accept
+      yes = FXButton.new(buttons, "&Yes", nil, dlg, FXDialogBox::ID_ACCEPT,
+			 FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X|
+			 LAYOUT_RIGHT|LAYOUT_CENTER_Y)
+      yes.connect(SEL_COMMAND) { 
+	dlg.close
+	if save
+	  @window.close
+	  return true
+	else
+	  return false
+	end
+      }
+      FXButton.new(buttons, "&No", nil, dlg, FXDialogBox::ID_ACCEPT,
+		   FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_RIGHT|LAYOUT_CENTER_Y)
+      
+      # Cancel
+      FXButton.new(buttons, "&Cancel", nil, dlg, FXDialogBox::ID_CANCEL,
+		   FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_RIGHT|LAYOUT_CENTER_Y)
+      yes.setDefault
+      yes.setFocus
+
+      return false if dlg.execute == 0
+    end
+    @window.close
+    return true
+  end
+
+
+  def _make_cursors
+    @@cursor_move = FXCursor.new(@window.getApp, CURSOR_MOVE)
+    @@cursor_move.create
+
+    @@cursor_arrow = FXCursor.new(@window.getApp, CURSOR_ARROW)
+    @@cursor_arrow.create
+    
+    @@cursor_cross = FXCursor.new(@window.getApp, CURSOR_CROSS)
+    @@cursor_cross.create
+    
+    @@cursor_updown = FXCursor.new(@window.getApp, CURSOR_UPDOWN)
+    @@cursor_updown.create
+
+    @@cursor_leftright = FXCursor.new(@window.getApp, CURSOR_LEFTRIGHT)
+    @@cursor_leftright.create
+  end
+
+  def _make_widgets
+    @scrollwindow = FXScrollWindow.new(@window, 
+				       SCROLLERS_NORMAL|SCROLLERS_TRACK)
+    width  = WW * @width
+    height = HH * @height
+
+    @canvasFrame = FXVerticalFrame.new(@scrollwindow,
+				       FRAME_SUNKEN|LAYOUT_FILL_X|
+				       LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_LEFT)
+
+    # First, create an off-screen image for drawing and double buffering
+    @image  = FXBMPImage.new(@window.getApp, nil, IMAGE_SHMI|IMAGE_SHMP, 
+			     width, height)
+    @image.create
+
+    # Then create canvas
+    @canvas = FXCanvas.new(@canvasFrame, nil, 0,
+    			   LAYOUT_FIX_WIDTH|LAYOUT_FIX_HEIGHT|
+			   LAYOUT_TOP|LAYOUT_LEFT,
+    			   0, 0, width, height)
+
+    @canvas.connect(SEL_PAINT) do |sender, sel, event|
+      draw(event)
+    end
+    @canvas.backColor = @options['BG Color']
+
+    @canvas.connect(SEL_MOUSEWHEEL, method(:mousewheel_cb))
+    @canvas.connect(SEL_LEFTBUTTONPRESS, method(:lmb_click_cb))
+    @canvas.connect(SEL_LEFTBUTTONRELEASE, method(:mmb_release_cb))
+    @canvas.connect(SEL_MOTION, method(:motion_cb))
+    @canvas.connect(SEL_MIDDLEBUTTONPRESS, method(:mmb_click_cb))
+    @canvas.connect(SEL_MIDDLEBUTTONRELEASE, method(:mmb_release_cb))
+    @canvas.connect(SEL_KEYPRESS, method(:keypress_cb))
+  end
+  
+  def initialize(name, parent = nil, default_options = nil,
+		 icon = nil, menu = nil, mode = nil, 
+		 x = 0, y = 0, w = 0, h = 0)
+    super(name)
+    @navigation = false
+    if parent
+      @window  = FXMDIChild.new(parent, name, icon, menu, mode, x, y, w, h)
+      @options = default_options
+      _make_cursors if not @@cursor_arrow
+      _make_widgets
+    end
+    empty_pathmap
+    self.zoom = 1
+  end
+
+
+  #
+  # Handle deleting selected rooms and/or connections
+  #
+  def delete_selected
+    rooms = @pages[@page].rooms.find_all { |r| r.selected }
+    conns = @pages[@page].connections.find_all { |c| c.selected }
+    ############################
+    # First, handle rooms...
+    ############################
+    # Remove rooms from path map
+    rooms.each { |r| @pmap[r.x][r.y] = nil }
+    # Remove rooms from current page in map
+    @pages[@page].rooms -= rooms
+    # Add any connections pointing to removed rooms as connection to remove
+    rooms.each { |r|
+      conns += r.exits.find_all { |e| e != nil }
+    }
+
+    #########################
+    # Now, handle connections
+    #########################
+    conns.uniq!
+
+    # Remove connections from path map
+    conns.each { |c| clean_path(c) }
+    # Remove connections from current page in map
+    @pages[@page].connections -= conns
+    # Remove room exits pointing to any removed connection
+    conns.each { |c|
+      a = c.roomA
+      b = c.roomB
+      a[a.exits.index(c)] = nil
+      idx = b.exits.rindex(c)
+      b[idx] = nil if idx
+    }
+
+    # Recreate pathmap.  We need to recreate pathmap for all paths
+    # as the removal of one path may help shorten the path of another.
+    create_pathmap
+
+    draw()
+  end
+
+  #
+  # Start a complex connection
+  #
+  def complex_connection
+    return if @complexConnection or @navigation
+    @complexConnection = true
+    status "Click on first room exit in complex connection."
+  end
+
+  #
+  # Given a selection of rooms, clear all of them from path map
+  #
+  def clean_room_selection(selection)
+    selection.each { |r| 
+      @pmap[r.x][r.y] = nil
+      clean_exits(r)
+    }
+  end
+
+  #
+  # Given a selection of rooms, clear all of them from path map
+  #
+  def store_room_selection(selection)
+    selection.each { |r| 
+      @pmap[r.x][r.y] = r
+    }
+    update_exits(selection)
+  end
+
+  #
+  # Clean all paths from path map for a room
+  #
+  def clean_exits(room)
+    room.exits.each { |c|
+      next if not c
+      clean_path(c)
+    }
+  end
+
+
+  #
+  # Find and update all paths in path map for a room
+  #
+  def update_exits(selection)
+    # We have to path_find all connections in the same order
+    # as they are stored in map, and not in how they are in the room
+    # so that there is consistency in path finding
+#     conns = []
+#     selection.each { |room|
+#       room.exits.each { |c|
+# 	conns << c
+#       }
+#     }
+
+#     @pages[@page].connections.each { |c|
+#       next if not conns.include?(c)
+#       path_find(c)
+#     }
+    create_pathmap
+    @modified = true
+  end
+
+  #
+  # Handle a keypress
+  #
+  def keypress_cb( server, sel, event)
+    case event.code
+    when KEY_Escape
+      if @complexConnection 
+	if @complexConnection.kind_of?(Array)
+	  @pages[@page].delete_connection_at(-1)
+	  status "Complex connection aborted."
+	  draw
+	end
+	@complexConnection = false
+      end
+    when KEY_BackSpace, KEY_Delete
+      return if @navigation
+      delete_selected
+    when KEY_c
+      if event.state & CONTROLMASK != 0
+	FXMapperWindow::copy_selected(self)
+	draw
+      end
+    when KEY_v
+      if event.state & CONTROLMASK != 0
+	FXMapperWindow::paste_selected(self)
+	@modified = true
+	draw
+      end
+    when KEY_x
+      return if @navigation
+      if event.state & CONTROLMASK != 0
+	FXMapperWindow::cut_selected(self)
+	@modified = true
+	draw
+      else
+	complex_connection
+      end
+    when KEY_Up
+      return if @navigation
+      selection = @pages[@page].rooms.find_all { |r| r.selected }
+      return if selection.empty?
+      clean_room_selection(selection)
+      # Check that all nodes can be moved up
+      selection.each { |r|
+	n = @pmap[r.x][r.y-1]
+	if r.y == 0 or n.kind_of?(Room)
+	  store_room_selection(selection)
+	  status "Cannot move selection up."
+	  return
+	end
+      }
+      selection.each { |r| 
+	r.y -= 1
+	@pmap[r.x][r.y] = r
+      }
+      update_exits(selection)
+      draw
+    when KEY_Down
+      return if @navigation
+      selection = @pages[@page].rooms.find_all { |r| r.selected }
+      return if selection.empty?
+      clean_room_selection(selection)
+      # Check that all nodes can be moved up
+      selection.each { |r|
+	n = @pmap[r.x][r.y+1]
+	if r.y+1 == @height or n.kind_of?(Room)
+	  store_room_selection(selection)
+	  status "Cannot move selection down."
+	  return
+	end
+      }
+      selection.each { |r| 
+	r.y += 1
+	@pmap[r.x][r.y] = r
+      }
+      update_exits(selection)
+      draw
+    when KEY_Left
+      return if @navigation
+      selection = @pages[@page].rooms.find_all { |r| r.selected }
+      return if selection.empty?
+      # Check that all nodes can be moved up
+      clean_room_selection(selection)
+      selection.each { |r|
+	n = @pmap[r.x-1][r.y]
+	if r.x == 0 or n.kind_of?(Room)
+	  store_room_selection(selection)
+	  status "Cannot move selection left."
+	  return
+	end
+      }
+      selection.each { |r| 
+	r.x -= 1
+	@pmap[r.x][r.y] = r
+      }
+      update_exits(selection)
+      draw
+    when KEY_Right
+      return if @navigation
+      selection = @pages[@page].rooms.find_all { |r| r.selected }
+      return if selection.empty?
+      # Check that all nodes can be moved up
+      clean_room_selection(selection)
+      selection.each { |r|
+	n = @pmap[r.x+1][r.y]
+	if r.x+1 == @width or n.kind_of?(Room)
+	  store_room_selection(selection)
+	  status "Cannot move selection right."
+	  return
+	end
+      }
+      selection.each { |r| 
+	r.x += 1
+	@pmap[r.x][r.y] = r
+      }
+      update_exits(selection)
+      draw
+    end
+  end
+
+  #
+  # Draw template of diagonal connections in grid background
+  #
+  def draw_diagonal_connections(dc, event)
+    ww = WW * @zoom
+    hh = HH * @zoom
+
+    w = W * @zoom
+    h = H * @zoom
+
+    ws = WS * @zoom
+    hs = HS * @zoom
+
+    ws_2 = WS_2 * @zoom
+    hs_2 = HS_2 * @zoom
+
+    maxy = @height - 1
+    maxx = @width  - 1
+
+    (0...@height).each { |yy|
+      (0...@width).each { |xx|
+	next if @pmap[xx][yy].kind_of?(Connection)
+	x = xx * ww
+	y = yy * hh
+
+	if yy < maxy and xx < maxx
+	  # First, draw \
+	  x1 = x + w + ws_2
+	  y1 = y + h + hs_2
+	  
+	  x2 = x1 + ws
+	  y2 = y1 + hs
+	  dc.drawLine( x1, y1, x2, y2 )
+
+	end
+
+	if yy < maxy and xx > 0 and xx <= maxx
+	  # Then, draw /
+	  x1 = x + ws_2
+	  y1 = y + h + hs_2
+
+	  x2 = x1 - ws
+	  y2 = y1 + hs
+	  dc.drawLine( x2, y2, x1, y1 )
+	end
+      }
+    }
+  end
+
+  #
+  # Draw template of straight connections in grid background
+  #
+  def draw_straight_connections(dc, event)
+    ww = WW * @zoom
+    hh = HH * @zoom
+
+    w = W * @zoom
+    h = H * @zoom
+
+    ws_2 = WS_2 * @zoom
+    hs_2 = HS_2 * @zoom
+
+    # First, draw horizontal lines
+    (0...@height).each { |yy|
+      (0..@width-2).each { |xx|
+	next if @pmap[xx][yy].kind_of?(Connection) or
+	  @pmap[xx+1][yy].kind_of?(Connection)
+	x1 =       xx * ww + w + ws_2
+	x2 = (xx + 1) * ww + ws_2
+    	y1 = yy * hh + h / 2 + hs_2
+	
+	dc.drawLine( x1, y1, x2, y1 )
+      }
+    }
+
+    # Then, draw vertical lines
+    (0...@width).each { |xx|
+      (0..@height-2).each { |yy|
+	next if @pmap[xx][yy].kind_of?(Connection) or
+	  @pmap[xx][yy+1].kind_of?(Connection)
+	x1 = xx * ww + w / 2 + ws_2
+    	y1 =       yy * hh + h + hs_2
+	y2 = (yy + 1) * hh + hs_2
+	
+	dc.drawLine( x1, y1, x1, y2 )
+      }
+    }
+  end
+
+
+
+  #
+  # Draw template of room squares in background
+  #
+  def draw_grid(dc, event)
+
+    dc.foreground = "black"
+    dc.lineWidth  = 0
+    dc.lineStyle  = LINE_ONOFF_DASH
+
+    ww = WW * @zoom
+    hh = HH * @zoom
+
+    w = W * @zoom
+    h = H * @zoom
+
+    ws_2 = WS_2 * @zoom
+    hs_2 = HS_2 * @zoom
+
+    (0...@width).each { |xx|
+      (0...@height).each { |yy|
+	next if @pmap[xx][yy]
+	x = xx * ww + ws_2
+    	y = yy * hh + hs_2
+	dc.drawRectangle( x, y, w, h )
+      }
+    }
+  end
+
+  #
+  # Clean background to solid color
+  #
+  def draw_background(dc, event = nil)
+    dc.foreground = @canvas.backColor
+    
+    if event
+      dc.fillRectangle(event.rect.x, event.rect.y, event.rect.w, event.rect.h)
+    else
+      dc.fillRectangle(0,0, @canvas.width, @canvas.height)
+    end
+  end
+
+  #
+  # Draw connections among rooms
+  #
+  def draw_connections(dc)
+    dc.lineStyle = LINE_SOLID
+    dc.lineWidth = 3 * @zoom
+    dc.lineWidth = 3 if dc.lineWidth < 3
+    @pages[@page].connections.each { |c| c.draw(dc, @zoom, @options) }
+  end
+
+  #
+  # Draw rooms
+  #
+  def draw_rooms(dc)
+    data = { }
+    data['font']    = @font
+    data['objfont'] = @objfont
+    @pages[@page].rooms.each_with_index { |room, idx| 
+      room.draw(dc, @zoom, idx, @options, data) 
+    }
+  end
+
+  #
+  # Print map
+  #
+  def print(printer)
+  end
+
+  #
+  # Draw map
+  #
+  def draw(event = nil)
+    pos = @scrollwindow.position
+    w   = @scrollwindow.getViewportWidth
+    h   = @scrollwindow.getViewportHeight
+
+    dc = FXDCWindow.new(@image)
+    dc.setClipRectangle( -pos[0]-5, -pos[1]-5, w, h)
+    dc.font = @font
+    # dc.lineCap = CAP_ROUND
+    draw_background(dc, event)
+    draw_grid(dc, event) if @options['Grid Boxes']
+    if @options['Grid Straight Connections']
+      draw_straight_connections(dc, event)
+    end
+    if @options['Grid Diagonal Connections']
+      draw_diagonal_connections(dc, event)
+    end
+    draw_connections(dc)
+    draw_rooms(dc)
+    dc.end
+    
+
+
+    # Blit the off-screen image into canvas
+    dc = FXDCWindow.new(@canvas)
+    dc.setClipRectangle( -pos[0]-5, -pos[1]-5, w, h)
+    dc.drawImage(@image,0,0)
+    dc.end
+  end
+
+
+
+  def _save
+    if @complexConnection
+      # If we have an incomplete connection, remove it
+      @pages[@page].delete_connection_at(-1)
+    end
+
+    if @filename !~ /\.map$/i
+      @filename << '.map'
+    end
+
+    status "Saving '#{@filename}'..."
+    @version = FILE_FORMAT_VERSION
+    begin
+      f = File.open(@filename, "wb")
+      f.puts Marshal.dump(self)
+      f.close
+    rescue => e
+      status "Could not save '#{@filename}': #{e}"
+      sleep 4
+      return false
+    end
+    @modified = false
+    status "Saved '#{@filename}'."
+    sleep 0.5
+    return true
+  end
+
+  def save
+    unless @filename
+      save_as
+    else
+      _save
+    end
+  end
+
+  def save_as
+    file = FXMapFileDialog.new(@window, "Save Map #{@name}").filename
+    if file != ''
+      @filename = file
+      return _save
+    end
+    return false
+  end
+
+  
+  def properties
+    if not @@win
+      @@win = FXMapDialogBox.new(@window)
+    end
+    @@win.copy_from(self)
+    @@win.show
+  end
+
+end