# Module: MASTERFunctions
# Tcl version: 7.3 (Tcl/Tk/XF)
# Tk version: 3.6
# XF version: $__lastrelease$
#

# module contents
global moduleList
global autoLoadList
set moduleList(MASTERFunctions) {Center Down DownLeft DownRight Left 
				 MasterChangeMode MasterSubSubModeChange 
				 Move Up UpLeft UpRight Right 
				 MasterAddCharacter MasterRemoveCharacter 
				 MasterAddCombatant MasterGoto 
				 MasterMeleeDamage MasterMeleeHit 
				 MasterNextMeleeRound MasterSelectAttacker 
				 MasterSelectDefender MasterViewCharacter 
				 MasterInsertMarchIcon MasterRemoveMarchIcon 
				 MasterIconSelect MasterAddTrick 
				 MasterRemoveTrick MasterViewTrick 
				 MasterAddOther MasterRemoveOther 
				 MasterViewOther MasterAddTreasure 
				 MasterRemoveTreasure MasterViewTreasure 
				 MasterAddMonster MasterRemoveMonster 
				 MasterViewMonster DescribeBitMap MoveDrag 
				 MoveEnd MoveStart CheckMasterMode 
				 MasterCreateNewTreasure MasterCreateNewTrick 
				 MasterCreateTrickTreasureFormReset 
				 MasterCreateMonster MasterCreateNPC 
				 MasterNewFrame MasterOpenFrame 
				 MasterSaveFrame MasterSaveFrameAs 
				 MasterInstallDoors MasterResetDoors 
				 MasterAddSpace MasterRemoveSpace 
				 MasterUpdateSpace MasterEditDungeonComments 
				 MasterEditGameNotes MasterDrawSpaceExits 
				 MasterExitButtonSet MasterExitButtonGet
				 MasterAddEncumbrence MasterRemoveEncumbrence
				 MasterListEncumbrences}
set autoLoadList(MASTERFunctions) {1}

# procedures to show toplevel windows


# User defined procedures


# Procedure: Center
proc Center {upordown} {
  if {$upordown == {Up}} {
    Move 0 0 -1
  } else {
    Move 0 0 1
  } 
}


# Procedure: Down
proc Down {} {
  Move 0 1 0
}


# Procedure: DownLeft
proc DownLeft {} {
  Move -1 1 0
}


# Procedure: DownRight
proc DownRight {} {
  Move 1 1 0
}


# Procedure: Left
proc Left {} {
  Move -1 0 0
}


# Procedure: MasterChangeMode
proc MasterChangeMode { newmode} {
  case $newmode in {
    {Build} {
      [SN MasterAddCharacterButton] configure -state disabled  
      [SN MasterRemoveCharacterButton] configure -state disabled  
      [SN MasterAddEncumbrenceButton] configure -state disabled  
      [SN MasterRemoveEncumbrenceButton] configure -state disabled  
      [SN MasterListEncumbrencesButton] configure -state disabled  
      [SN MasterMeleeSubMode] configure -state disabled
      [SN MasterCreateSubMode] configure -state normal
      [SN MasterExitsSubMode] configure -state normal
      [SN MasterMonstersSubModeFrameCreateMonster] configure -state normal
      [SN MasterMonstersSubModeFrameCreateNPC] configure -state normal
      global MasterSubSubMode
      if {$MasterSubSubMode == "Melee"} {
	set MasterSubSubMode "Monsters"
	MasterSubSubModeChange Monsters
      }
      foreach m {Monsters Other Treasure Tricks} {
	foreach b {Add Remove} {
	  [SN [join [list Master $m SubModeFrame $b] ""]] configure -state normal
	}
      }
      [SN MasterExitsSubModeFrame].buttons.install configure -state normal
      [SN MasterExitsSubModeFrame].buttons.reset configure -state normal
      foreach b [winfo children [SN MasterSpaceButtons]] {
        $b configure -state normal
      }
    }
    {Play} {
      global CurrentMasterGame
      if {$CurrentMasterGame(handle) == {}} {
	global {CurrentMasterDungeon}
	set CurrentMasterGame(handle) [Game $CurrentMasterDungeon(handle) $CurrentMasterDungeon(filename) "" 0 0 0]
	set CurrentMasterGame(isdirty) 1
	set CurrentMasterGame(filename) new.game
      }
      [SN MasterMeleeSubMode] configure -state normal
      [SN MasterAddCharacterButton] configure -state normal
      [SN MasterRemoveCharacterButton] configure -state normal
      [SN MasterAddEncumbrenceButton] configure -state normal
      [SN MasterRemoveEncumbrenceButton] configure -state normal
      [SN MasterListEncumbrencesButton] configure -state normal
      [SN MasterCreateSubMode] configure -state disabled
      [SN MasterMonstersSubModeFrameCreateMonster] configure -state disabled
      [SN MasterMonstersSubModeFrameCreateNPC] configure -state disabled
      global MasterSubSubMode
      if {$MasterSubSubMode == "Create"} {
	set MasterSubSubMode "Monsters"
	MasterSubSubModeChange Monsters
      }
      foreach m {Monsters Other Treasure Tricks} {
	foreach b {Add Remove} {
	  [SN [join [list Master $m SubModeFrame $b] ""]] configure -state disabled
	}
      }
      [SN MasterExitsSubModeFrame].buttons.install configure -state disabled
      [SN MasterExitsSubModeFrame].buttons.reset configure -state disabled
      foreach b [winfo children [SN MasterSpaceButtons]] {
        $b configure -state disabled
      }
    }
  }
}


# Procedure: MasterSubSubModeChange
proc MasterSubSubModeChange { NewMode} {
  foreach s [pack slaves [SN MasterSubSubFrame]] {
    pack forget $s
  }
  set frame [join [list Master $NewMode SubModeFrame] ""]
  pack append [SN MasterSubSubFrame] [SN $frame] {top frame center expand fill}
  if {$NewMode == "Create"} {
    focus [SN MasterCreateTrickTreasureName]
  }
  if {$NewMode == "Melee"} {
    [SN MasterMeleeDamageValue] configure -text {}
    [SN MasterMeleeHitValue] configure -text {}
    [SN MasterCurrentMeleeRound] configure -text {0}
    [SN MasterMeleeDamageND] delete 0 end
    [SN MasterMeleeDamageND] insert end {1}
    [SN MasterMeleeDamageNS] delete 0 end
    [SN MasterMeleeDamageNS] insert end {6}
    [SN MasterMeleeHitND] delete 0 end
    [SN MasterMeleeHitND] insert end {1}
    [SN MasterMeleeHitNS] delete 0 end
    [SN MasterMeleeHitNS] insert end {6}
    CLDelete [SN MasterMeleeCombatants] 0 \
	     [expr [CLSize [SN MasterMeleeCombatants]] - 1]
    focus [SN MasterMeleeHitND]
  }
}


# Procedure: Move
proc Move { newx newy newl} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  set levels [$CurrentMasterDungeon(handle) levels]
  set xsize  [$CurrentMasterDungeon(handle) xsize]
  set ysize  [$CurrentMasterDungeon(handle) ysize]
  set level  [expr $CurrentMasterDungeon(level) + $newl]
  set x      [expr $CurrentMasterDungeon(x) + $newx]
  set y      [expr $CurrentMasterDungeon(y) + $newy]
  if {$level < 0} {
    return
  }
  if {$x < 0} {
    return
  }
  if {$y < 0} {
    return
  }
  if {$level >= $levels} {
    return
  }
  if {$x >= $xsize} {
    return
  }
  if {$y >= $ysize} {
    return
  }
  set CurrentMasterDungeon(level) $level
  set CurrentMasterDungeon(x) $x
  set CurrentMasterDungeon(y) $y
  [SN MasterLocationLevel] delete 0 end
  [SN MasterLocationLevel] insert end $CurrentMasterDungeon(level)
  [SN MasterLocationX] delete 0 end
  [SN MasterLocationX] insert end $CurrentMasterDungeon(x)
  [SN MasterLocationY] delete 0 end
  [SN MasterLocationY] insert end $CurrentMasterDungeon(y)
  UpdateSpaceForm
}


# Procedure: Up
proc Up {} {
  Move 0 -1 0
}


# Procedure: UpLeft
proc UpLeft {} {
  Move -1 -1 0
}


# Procedure: UpRight
proc UpRight {} {
  Move 1 -1 0
}


# Procedure: Right
proc Right {} {
  Move 1 0 0
}


# Procedure: MasterAddCharacter
proc MasterAddCharacter {} {
  global CurrentMasterGame
  if {$CurrentMasterGame(handle) == {}} {return}
  global fsBox
  set fsBox(pattern) {*.character*}
  set fsBox(showPixmap) 0
  set charfile [FSBox "Select character file: "]
  if {$charfile == ""} {
    return
  }
  if {![file exists $charfile]} {
    return
  }
  set charfile [TrimPathPrefix $charfile]
  set handle [Character]
  if {[catch [list $handle read $charfile] error] != 0} {
    $handle delete
    return
  }
  set fsBox(showPixmap) 1
  set fsBox(pattern) {*.xbm*}
  set bm [FSBox "Select character bitmap: "]
  set fsBox(showPixmap) 0
  if {$bm == ""} {
    set bm questhead
  } else {
    set file [string range $bm 1 end]
    if {![file exists $file]} {
      set bm questhead
    } else {
      if {[catch [list [SN MasterMarchCanvas] create bitmap 0 0 -bitmap $bm] tag] == 0} {
	[SN MasterMarchCanvas] delete $tag
	set bm "@[TrimPathPrefix $file]"
      } else {
	set bm questhead
      }
    }
  }
  set characterList [CharacterList $handle $charfile $bm {} 0 0 {} [$handle hitpoints]] 
  set line "$characterList -  $handle - [$handle name] ([$handle player])"
  CLInsert [SN MasterCharacterList] end $bm $line
  MasterInsertMarchIcon $bm $characterList $line
  set xy [[SN MasterMarchCanvas] coords $characterList]
  $characterList marchx [lindex $xy 0]
  $characterList marchy [lindex $xy 1]
  $characterList nextcharacter [$CurrentMasterGame(handle) players]
  $CurrentMasterGame(handle) players $characterList
  set CurrentMasterGame(isdirty) 1
}


# Procedure: MasterAddEncumbrence
proc MasterAddEncumbrence {} {
  global CurrentMasterGame
  if {$CurrentMasterGame(handle) == {}} {return}
  if {[selection own] == [SN MasterCharacterList]} {
    set line [GetSelection]  
    if {$line == {}} {return}
    set chList [lindex [split $line] 0]

    global NewEncumbrence
    set NewEncumbrence {}

  # build widget .addEncumbrence
  if {"[info procs XFEdit]" != ""} {
    catch "XFDestroy .addEncumbrence"
  } {
    catch "destroy .addEncumbrence"
  }
  toplevel .addEncumbrence 

  # Window manager configurations
  global tkVersion
  wm positionfrom .addEncumbrence ""
  wm sizefrom .addEncumbrence program
  wm maxsize .addEncumbrence 1000 768
  wm minsize .addEncumbrence 10 10
  wm title .addEncumbrence {Add Encumbrence}


  # build widget .addEncumbrence.abilityAdjs
  frame .addEncumbrence.abilityAdjs \
    -borderwidth {2}

  # build widget .addEncumbrence.abilityAdjs.ch
  entry .addEncumbrence.abilityAdjs.ch \
    -relief {sunken}\
    -width {5}
  # bindings
  bind .addEncumbrence.abilityAdjs.ch <Key-Return> {focus .addEncumbrence.moveAdjs.move}
  bind .addEncumbrence.abilityAdjs.ch <Key-Tab> {focus .addEncumbrence.moveAdjs.move}

  # build widget .addEncumbrence.abilityAdjs.co
  entry .addEncumbrence.abilityAdjs.co \
    -relief {sunken}\
    -width {5}
  # bindings
  bind .addEncumbrence.abilityAdjs.co <Key-Return> {focus .addEncumbrence.abilityAdjs.ch}
  bind .addEncumbrence.abilityAdjs.co <Key-Tab> {focus .addEncumbrence.abilityAdjs.ch}

  # build widget .addEncumbrence.abilityAdjs.d
  entry .addEncumbrence.abilityAdjs.d \
    -relief {sunken}\
    -width {5}
  # bindings
  bind .addEncumbrence.abilityAdjs.d <Key-Return> {focus .addEncumbrence.abilityAdjs.co}
  bind .addEncumbrence.abilityAdjs.d <Key-Tab> {focus .addEncumbrence.abilityAdjs.co}

  # build widget .addEncumbrence.abilityAdjs.i
  entry .addEncumbrence.abilityAdjs.i \
    -relief {sunken}\
    -width {5}
  # bindings
  bind .addEncumbrence.abilityAdjs.i <Key-Return> {focus .addEncumbrence.abilityAdjs.w}
  bind .addEncumbrence.abilityAdjs.i <Key-Tab> {focus .addEncumbrence.abilityAdjs.w}

  # build widget .addEncumbrence.abilityAdjs.label22
  label .addEncumbrence.abilityAdjs.label22 \
    -text {S:}

  # build widget .addEncumbrence.abilityAdjs.label23
  label .addEncumbrence.abilityAdjs.label23 \
    -text {I:}

  # build widget .addEncumbrence.abilityAdjs.label24
  label .addEncumbrence.abilityAdjs.label24 \
    -text {W:}

  # build widget .addEncumbrence.abilityAdjs.label25
  label .addEncumbrence.abilityAdjs.label25 \
    -text {D:}

  # build widget .addEncumbrence.abilityAdjs.label26
  label .addEncumbrence.abilityAdjs.label26 \
    -text {CO:}

  # build widget .addEncumbrence.abilityAdjs.label27
  label .addEncumbrence.abilityAdjs.label27 \
    -text {CH:}

  # build widget .addEncumbrence.abilityAdjs.s
  entry .addEncumbrence.abilityAdjs.s \
    -relief {sunken}\
    -width {5}
  # bindings
  bind .addEncumbrence.abilityAdjs.s <Key-Return> {focus .addEncumbrence.abilityAdjs.i}
  bind .addEncumbrence.abilityAdjs.s <Key-Tab> {focus .addEncumbrence.abilityAdjs.i}

  # build widget .addEncumbrence.abilityAdjs.w
  entry .addEncumbrence.abilityAdjs.w \
    -relief {sunken}\
    -width {5}
  # bindings
  bind .addEncumbrence.abilityAdjs.w <Key-Return> {focus .addEncumbrence.abilityAdjs.d}
  bind .addEncumbrence.abilityAdjs.w <Key-Tab> {focus .addEncumbrence.abilityAdjs.d}

  # pack widget .addEncumbrence.abilityAdjs
  pack append .addEncumbrence.abilityAdjs \
    .addEncumbrence.abilityAdjs.label22 {left frame center} \
    .addEncumbrence.abilityAdjs.s {left frame center expand fillx} \
    .addEncumbrence.abilityAdjs.label23 {left frame center} \
    .addEncumbrence.abilityAdjs.i {left frame center expand fillx} \
    .addEncumbrence.abilityAdjs.label24 {left frame center} \
    .addEncumbrence.abilityAdjs.w {left frame center expand fillx} \
    .addEncumbrence.abilityAdjs.label25 {left frame center} \
    .addEncumbrence.abilityAdjs.d {left frame center expand fillx} \
    .addEncumbrence.abilityAdjs.label26 {left frame center} \
    .addEncumbrence.abilityAdjs.co {left frame center expand fillx} \
    .addEncumbrence.abilityAdjs.label27 {left frame center} \
    .addEncumbrence.abilityAdjs.ch {left frame center expand fillx} 

  # build widget .addEncumbrence.buttons
  frame .addEncumbrence.buttons \
    -borderwidth {2}

  # build widget .addEncumbrence.buttons.cancel
  button .addEncumbrence.buttons.cancel \
    -text {Cancel} \
    -command {CancelNewEncumbrence}

  # build widget .addEncumbrence.buttons.ok
  button .addEncumbrence.buttons.ok \
    -text {OK} \
    -command {MakeNewEncumbrence}

  # build widget .addEncumbrence.buttons.help
  button .addEncumbrence.buttons.help \
    -text {Help} \
    -command {PopupHelpTopic AddEncumbrence}

  # pack widget .addEncumbrence.buttons
  pack append .addEncumbrence.buttons \
    .addEncumbrence.buttons.ok {left frame center expand} \
    .addEncumbrence.buttons.cancel {left frame center expand} \
    .addEncumbrence.buttons.help {right frame center expand}

  # build widget .addEncumbrence.description
  frame .addEncumbrence.description \
    -borderwidth {2}

  # build widget .addEncumbrence.description.description
  entry .addEncumbrence.description.description \
    -relief {sunken}
  # bindings
  bind .addEncumbrence.description.description <Key-Return> {focus .addEncumbrence.weightAndValue.weight}
  bind .addEncumbrence.description.description <Key-Tab> {focus .addEncumbrence.weightAndValue.weight}

  # build widget .addEncumbrence.description.label11
  label .addEncumbrence.description.label11 \
    -text {Description:}

  # pack widget .addEncumbrence.description
  pack append .addEncumbrence.description \
    .addEncumbrence.description.label11 {left frame center} \
    .addEncumbrence.description.description {left frame center expand fillx} 

  # build widget .addEncumbrence.handle
  frame .addEncumbrence.handle \
    -borderwidth {2}

  # build widget .addEncumbrence.handle.button15
  button .addEncumbrence.handle.button15 \
    -command {set listelt [GetTrickTreasure "Treasure" mastertreasurelist]
if {$listelt != {}} {
  set handle [$listelt handle]
  .addEncumbrence.name.name delete 0 end
  .addEncumbrence.name.name insert end "[$handle name]"
  .addEncumbrence.description.description delete 0 end
  .addEncumbrence.description.description insert end "[$handle description]"
  .addEncumbrence.handle.handle configure -text "$handle"
}}\
    -text {Browse}

  # build widget .addEncumbrence.handle.handle
  label .addEncumbrence.handle.handle \
    -relief {sunken}\
    -text {}\
    -anchor w\
    -width {19}

  # build widget .addEncumbrence.handle.label13
  label .addEncumbrence.handle.label13 \
    -text {Trerasure Handle:}

  # pack widget .addEncumbrence.handle
  pack append .addEncumbrence.handle \
    .addEncumbrence.handle.label13 {left frame center} \
    .addEncumbrence.handle.handle {left frame center expand fillx} \
    .addEncumbrence.handle.button15 {right frame center} 

  # build widget .addEncumbrence.meleeAdjs
  frame .addEncumbrence.meleeAdjs \
    -borderwidth {2}

  # build widget .addEncumbrence.meleeAdjs.acAdj
  entry .addEncumbrence.meleeAdjs.acAdj \
    -relief {sunken}\
    -width {5}
  # bindings
  bind .addEncumbrence.meleeAdjs.acAdj <Key-Return> {focus .addEncumbrence.meleeAdjs.toHitAdj}
  bind .addEncumbrence.meleeAdjs.acAdj <Key-Tab> {focus .addEncumbrence.meleeAdjs.toHitAdj}

  # build widget .addEncumbrence.meleeAdjs.damAdj
  entry .addEncumbrence.meleeAdjs.damAdj \
    -relief {sunken}\
    -width {5}
  # bindings
  bind .addEncumbrence.meleeAdjs.damAdj <Key-Return> {focus .addEncumbrence.meleeAdjs.magResAdj}
  bind .addEncumbrence.meleeAdjs.damAdj <Key-Tab> {focus .addEncumbrence.meleeAdjs.magResAdj}

  # build widget .addEncumbrence.meleeAdjs.damProtAdj
  entry .addEncumbrence.meleeAdjs.damProtAdj \
    -relief {sunken}\
    -width {5}
  # bindings
  bind .addEncumbrence.meleeAdjs.damProtAdj <Key-Return> {focus .addEncumbrence.abilityAdjs.s}
  bind .addEncumbrence.meleeAdjs.damProtAdj <Key-Tab> {focus .addEncumbrence.abilityAdjs.s}

  # build widget .addEncumbrence.meleeAdjs.label20
  label .addEncumbrence.meleeAdjs.label20 \
    -text {AC:}

  # build widget .addEncumbrence.meleeAdjs.label22
  label .addEncumbrence.meleeAdjs.label22 \
    -text {ToHit:}

  # build widget .addEncumbrence.meleeAdjs.label23
  label .addEncumbrence.meleeAdjs.label23 \
    -text {Damage:}

  # build widget .addEncumbrence.meleeAdjs.label24
  label .addEncumbrence.meleeAdjs.label24 \
    -text {Magic Resistance:}

  # build widget .addEncumbrence.meleeAdjs.label25
  label .addEncumbrence.meleeAdjs.label25 \
    -text {Damage Protection:}

  # build widget .addEncumbrence.meleeAdjs.magResAdj
  entry .addEncumbrence.meleeAdjs.magResAdj \
    -relief {sunken}\
    -width {5}
  # bindings
  bind .addEncumbrence.meleeAdjs.magResAdj <Key-Return> {focus .addEncumbrence.meleeAdjs.damProtAdj}
  bind .addEncumbrence.meleeAdjs.magResAdj <Key-Tab> {focus .addEncumbrence.meleeAdjs.damProtAdj}

  # build widget .addEncumbrence.meleeAdjs.toHitAdj
  entry .addEncumbrence.meleeAdjs.toHitAdj \
    -relief {sunken}\
    -width {5}
  # bindings
  bind .addEncumbrence.meleeAdjs.toHitAdj <Key-Return> {focus .addEncumbrence.meleeAdjs.damAdj}
  bind .addEncumbrence.meleeAdjs.toHitAdj <Key-Tab> {focus .addEncumbrence.meleeAdjs.damAdj}

  # pack widget .addEncumbrence.meleeAdjs
  pack append .addEncumbrence.meleeAdjs \
    .addEncumbrence.meleeAdjs.label20 {left frame center} \
    .addEncumbrence.meleeAdjs.acAdj {left frame center expand fillx} \
    .addEncumbrence.meleeAdjs.label22 {left frame center} \
    .addEncumbrence.meleeAdjs.toHitAdj {left frame center expand fillx} \
    .addEncumbrence.meleeAdjs.label23 {left frame center} \
    .addEncumbrence.meleeAdjs.damAdj {left frame center expand fillx} \
    .addEncumbrence.meleeAdjs.label24 {left frame center} \
    .addEncumbrence.meleeAdjs.magResAdj {left frame center expand fillx} \
    .addEncumbrence.meleeAdjs.label25 {left frame center} \
    .addEncumbrence.meleeAdjs.damProtAdj {left frame center expand fillx} 

  # build widget .addEncumbrence.moveAdjs
  frame .addEncumbrence.moveAdjs \
    -borderwidth {2}

  # build widget .addEncumbrence.moveAdjs.fly
  entry .addEncumbrence.moveAdjs.fly \
    -relief {sunken}\
    -width {5}
  # bindings
  bind .addEncumbrence.moveAdjs.fly <Key-Return> {focus .addEncumbrence.moveAdjs.swim}
  bind .addEncumbrence.moveAdjs.fly <Key-Tab> {focus .addEncumbrence.moveAdjs.swim}

  # build widget .addEncumbrence.moveAdjs.label22
  label .addEncumbrence.moveAdjs.label22 \
    -text {Move:}

  # build widget .addEncumbrence.moveAdjs.label23
  label .addEncumbrence.moveAdjs.label23 \
    -text {Fly:}

  # build widget .addEncumbrence.moveAdjs.label24
  label .addEncumbrence.moveAdjs.label24 \
    -text {Swim:}

  # build widget .addEncumbrence.moveAdjs.move
  entry .addEncumbrence.moveAdjs.move \
    -relief {sunken}\
    -width {5}
  # bindings
  bind .addEncumbrence.moveAdjs.move <Key-Return> {focus .addEncumbrence.moveAdjs.fly}
  bind .addEncumbrence.moveAdjs.move <Key-Tab> {focus .addEncumbrence.moveAdjs.fly}

  # build widget .addEncumbrence.moveAdjs.swim
  entry .addEncumbrence.moveAdjs.swim \
    -relief {sunken}\
    -width {5}
  # bindings
  bind .addEncumbrence.moveAdjs.swim <Key-Return> {focus .addEncumbrence.name.name}
  bind .addEncumbrence.moveAdjs.swim <Key-Tab> {focus .addEncumbrence.name.name}

  # pack widget .addEncumbrence.moveAdjs
  pack append .addEncumbrence.moveAdjs \
    .addEncumbrence.moveAdjs.label22 {left frame center} \
    .addEncumbrence.moveAdjs.move {left frame center expand fillx} \
    .addEncumbrence.moveAdjs.label23 {left frame center} \
    .addEncumbrence.moveAdjs.fly {left frame center expand fillx} \
    .addEncumbrence.moveAdjs.label24 {left frame center} \
    .addEncumbrence.moveAdjs.swim {left frame center expand fillx} 

  # build widget .addEncumbrence.name
  frame .addEncumbrence.name \
    -borderwidth {2}

  # build widget .addEncumbrence.name.label9
  label .addEncumbrence.name.label9 \
    -text {Name:}

  # build widget .addEncumbrence.name.name
  entry .addEncumbrence.name.name \
    -relief {sunken}
  # bindings
  bind .addEncumbrence.name.name <Key-Return> {focus .addEncumbrence.description.description}
  bind .addEncumbrence.name.name <Key-Tab> {focus .addEncumbrence.description.description}

  # pack widget .addEncumbrence.name
  pack append .addEncumbrence.name \
    .addEncumbrence.name.label9 {left frame center} \
    .addEncumbrence.name.name {left frame center expand fillx} 

  # build widget .addEncumbrence.weightAndValue
  frame .addEncumbrence.weightAndValue \
    -borderwidth {2}

  # build widget .addEncumbrence.weightAndValue.label16
  label .addEncumbrence.weightAndValue.label16 \
    -text {Weight:}

  # build widget .addEncumbrence.weightAndValue.label18
  label .addEncumbrence.weightAndValue.label18 \
    -text {Value:}

  # build widget .addEncumbrence.weightAndValue.value
  entry .addEncumbrence.weightAndValue.value \
    -relief {sunken}
  # bindings
  bind .addEncumbrence.weightAndValue.value <Key-Return> {focus .addEncumbrence.meleeAdjs.acAdj}
  bind .addEncumbrence.weightAndValue.value <Key-Tab> {focus .addEncumbrence.meleeAdjs.acAdj}

  # build widget .addEncumbrence.weightAndValue.weight
  entry .addEncumbrence.weightAndValue.weight \
    -relief {sunken}
  # bindings
  bind .addEncumbrence.weightAndValue.weight <Key-Return> {focus .addEncumbrence.weightAndValue.value}
  bind .addEncumbrence.weightAndValue.weight <Key-Tab> {focus .addEncumbrence.weightAndValue.value}

  # pack widget .addEncumbrence.weightAndValue
  pack append .addEncumbrence.weightAndValue \
    .addEncumbrence.weightAndValue.label16 {left frame center} \
    .addEncumbrence.weightAndValue.weight {left frame center expand fillx} \
    .addEncumbrence.weightAndValue.label18 {left frame center} \
    .addEncumbrence.weightAndValue.value {left frame center expand fillx} 

  # pack widget .addEncumbrence
  pack append .addEncumbrence \
    .addEncumbrence.name {top frame center fillx} \
    .addEncumbrence.description {top frame center fillx} \
    .addEncumbrence.handle {top frame center fillx} \
    .addEncumbrence.weightAndValue {top frame center fillx} \
    .addEncumbrence.meleeAdjs {top frame center fillx} \
    .addEncumbrence.abilityAdjs {top frame center fillx} \
    .addEncumbrence.moveAdjs {top frame center fillx} \
    .addEncumbrence.buttons {top frame center fillx} 

  .addEncumbrence.abilityAdjs.ch insert end {0}
  .addEncumbrence.abilityAdjs.co insert end {0}
  .addEncumbrence.abilityAdjs.d insert end {0}
  .addEncumbrence.abilityAdjs.i insert end {0}
  .addEncumbrence.abilityAdjs.s insert end {0}
  .addEncumbrence.abilityAdjs.w insert end {0}
  .addEncumbrence.description.description insert end {}
  .addEncumbrence.meleeAdjs.acAdj insert end {0}
  .addEncumbrence.meleeAdjs.damAdj insert end {0}
  .addEncumbrence.meleeAdjs.damProtAdj insert end {0}
  .addEncumbrence.meleeAdjs.magResAdj insert end {0}
  .addEncumbrence.meleeAdjs.toHitAdj insert end {0}
  .addEncumbrence.moveAdjs.fly insert end {0}
  .addEncumbrence.moveAdjs.move insert end {0}
  .addEncumbrence.moveAdjs.swim insert end {0}
  .addEncumbrence.name.name insert end {}
  .addEncumbrence.weightAndValue.value insert end {0}
  .addEncumbrence.weightAndValue.weight insert end {0}


# end of widget tree

    update idletasks
    grab .addEncumbrence
    tkwait window .addEncumbrence

    if {$NewEncumbrence == {}} {return}

    $NewEncumbrence nextencumbrence [$chList encumbrences]
    $chList encumbrences $NewEncumbrence
    set CurrentMasterGame(isdirty) 1
  }
}

# Procedure: IsInteger
proc IsInteger {i} {
  if {[catch "expr int($i)"]} {
    return 0
  } else {
    return 1
  }
}

# Procedure: IsPosInteger
proc IsPosInteger {i} {
  if {[IsInteger $i]} {
    if {$i < 0} {
      return 0
    } else {
      return 1
    }
  } else {
    return 0
  }
}




# Procedure: MakeNewEncumbrence
proc MakeNewEncumbrence {} {
  set handle [lindex [.addEncumbrence.handle.handle configure -text] 4]
  set description [.addEncumbrence.description.description get]
  set name [.addEncumbrence.name.name get]

  foreach x {acAdj damAdj damProtAdj magResAdj toHitAdj} {
    set v [.addEncumbrence.meleeAdjs.$x get]
    if {[string index $v 0] == "+"} {set v [string range $v 1 end]}
    if {![IsInteger $v]} {
      AlertBox "Not an integer for $x: $v, re-enter"
      .addEncumbrence.meleeAdjs.$x delete 0 end
      .addEncumbrence.meleeAdjs.$x insert end {0}
      return
    }
    set $x $v
  }

  foreach x {value weight} {
    set v [.addEncumbrence.weightAndValue.$x get]
    if {![IsPosInteger $v]} {
      AlertBox "Not a positive integer for $x: $v, re-enter"
      .addEncumbrence.weightAndValue.$x delete 0 end
      .addEncumbrence.weightAndValue.$x insert end {0}
      return
    }
    set $x $v
  }
  set abilityAdjs {}
  foreach x {s i w d co co} {
    set v [.addEncumbrence.abilityAdjs.$x get]
    if {[string index $v 0] == "+"} {set v [string range $v 1 end]}
    if {![IsInteger $v]} {
      AlertBox "Not an integer for $x: $v, re-enter"
      .addEncumbrence.abilityAdjs.$x delete 0 end
      .addEncumbrence.abilityAdjs.$x insert end {0}
      return
    }
    lappend abilityAdjs $v
  }
  set moveAdjs {}
  foreach x {move fly swim} {
    set v [.addEncumbrence.moveAdjs.$x get]
    if {[string index $v 0] == "+"} {set v [string range $v 1 end]}
    if {![IsInteger $v]} {
      AlertBox "Not an integer for $x: $v, re-enter"
      .addEncumbrence.moveAdjs.$x delete 0 end
      .addEncumbrence.moveAdjs.$x insert end {0}
      return
    }
    lappend moveAdjs $v
  }
  if {"[info procs XFEdit]" != ""} {
    catch "XFDestroy .addEncumbrence"
  } {
    catch "destroy .addEncumbrence"
  }
  global NewEncumbrence
  set NewEncumbrence [EncumbrenceList "$name" "$handle" "$description" $weight \
				      $acAdj $toHitAdj $damAdj $magResAdj \
				      $damProtAdj $abilityAdjs $moveAdjs $value \
				      {}]
}

# Procedure: CancelNewEncumbrence
proc CancelNewEncumbrence {} {
  global NewEncumbrence
  set NewEncumbrence {}
  if {"[info procs XFEdit]" != ""} {
    catch "XFDestroy .addEncumbrence"
  } {
    catch "destroy .addEncumbrence"
  }
}

# Procedure: MasterRemoveEncumbrence
proc MasterRemoveEncumbrence {} {
  global CurrentMasterGame
  if {$CurrentMasterGame(handle) == {}} {return}
  if {[selection own] == [SN MasterCharacterList]} {
    set line [GetSelection]  
    if {$line == {}} {return}
    set chList [lindex [split $line] 0]
    set encumbrenceList [$chList encumbrences]
    if {$encumbrenceList == {}} {return}
    set selectedEncumbrence [SelectEncumbrence [$encumbrenceList list]]
    if {$selectedEncumbrence == {}} {return}
    if {$selectedEncumbrence == $encumbrenceList} {
      $chList encumbrences [$encumbrenceList nextencumbrence]
      $encumbrenceList delete
      set CurrentMasterGame(isdirty) 1
    } else {
      while {[$encumbrenceList nextencumbrence] != $selectedEncumbrence && \
	     [$encumbrenceList nextencumbrence] != {}} {
	set encumbrenceList [$encumbrenceList nextencumbrence]
      }
      if {[$encumbrenceList nextencumbrence] == $selectedEncumbrence} {
	$encumbrenceList nextencumbrence [$selectedEncumbrence nextencumbrence]
	$selectedEncumbrence delete
	set CurrentMasterGame(isdirty) 1
      }
    }
  }
}

# Procedure: MasterListEncumbrences
proc MasterListEncumbrences {} {
  global CurrentMasterGame
  if {$CurrentMasterGame(handle) == {}} {return}
  if {[selection own] == [SN MasterCharacterList]} {
    set line [GetSelection]  
    if {$line == {}} {return}
    set chList [lindex [split $line] 0]
    set encumbrenceList [$chList encumbrences]
    if {$encumbrenceList == {}} {return}
    set encumbrences [$encumbrenceList list]
# .encumbrences
# The above line makes pasting MUCH easier for me.
# It contains the pathname of the cutted widget.
# Tcl version: 7.3 (Tcl/Tk/XF)
# Tk version: 3.6
# XF version: $__lastrelease$
#

  # build widget .encumbrences
  if {"[info procs XFEdit]" != ""} {
    catch "XFDestroy .encumbrences"
  } {
    catch "destroy .encumbrences"
  }
  toplevel .encumbrences 

  # Window manager configurations
  global tkVersion
  wm positionfrom .encumbrences ""
  wm sizefrom .encumbrences program
  wm maxsize .encumbrences 1000 768
  wm minsize .encumbrences 10 10
  wm title .encumbrences {Encumprence List}


  # build widget .encumbrences.frame
  frame .encumbrences.frame \
    -relief {raised}

  # build widget .encumbrences.frame.scrollbar1
  scrollbar .encumbrences.frame.scrollbar1 \
    -command {.encumbrences.frame.text2 yview}\
    -relief {raised}

  # build widget .encumbrences.frame.text2
  text .encumbrences.frame.text2 \
    -borderwidth {2}\
    -relief {raised}\
    -wrap {none}\
    -yscrollcommand {.encumbrences.frame.scrollbar1 set}
  # bindings
  bind .encumbrences.frame.text2 <Any-Key> {NoFunction}

  # pack widget .encumbrences.frame
  pack append .encumbrences.frame \
    .encumbrences.frame.scrollbar1 {right frame center filly} \
    .encumbrences.frame.text2 {top frame center expand fill} 

  # build widget .encumbrences.ok
  button .encumbrences.ok \
    -text {OK}\
    -command {
  if {"[info procs XFEdit]" != ""} {
    catch "XFDestroy .encumbrences"
  } {
    catch "destroy .encumbrences"
  }
}

  # pack widget .encumbrences
  pack append .encumbrences \
    .encumbrences.frame {top frame center fill} \
    .encumbrences.ok {top frame center fill} 

  .encumbrences.frame.text2 insert end {}
  foreach e $encumbrences {
    .encumbrences.frame.text2 insert end \
	"$e - [$e name]: Weight [$e weight], Value [$e value]\n"
    set indent [string range "                                        " 0 \
    		[expr [string length $e] + 3]]
    .encumbrences.frame.text2 insert end "$indent"
    set ll [string length $indent]
    foreach ma {{acadj AC} {tohitadj {To Hit}} {damadj Damage} 
		{magresadj {Magical Resistance}} 
		{damprotadj {Damage Protection}}} {
      set adj [$e [lindex $ma 0]]
      set str {}
      if {$adj < 0} {
	set str "[lindex $ma 1]: $adj"
      } elseif {$adj > 0} {
	set str "[lindex $ma 1]: +$adj"
      }
      if {[expr $ll + [string length $str]] > 79} {
	.encumbrences.frame.text2 insert end "\n$indent"
	set ll [string length $indent]
      }
      .encumbrences.frame.text2 insert end "$str"
      incr ll [string length $str]
    }
    
    set abil [$e abilityadjs]
    foreach a {{0 S} {1 I} {2 W} {3 D} {4 CO} {5 CH}} {
      set adj [lindex $abil [lindex $a 0]]
      set str {}
      if {$adj < 0} {
	set str "[lindex $a 1]: $adj"
      } elseif {$adj > 0} {
	set str "[lindex $a 1]: +$adj"
      }
      if {[expr $ll + [string length $str]] > 79} {
	.encumbrences.frame.text2 insert end "\n$indent"
	set ll [string length $indent]
      }
      .encumbrences.frame.text2 insert end "$str"
      incr ll [string length $str]
    }
    set move [$e moveadj]
    foreach m {{0 Move} {1 Fly} {2 Swim}} {
      set adj [lindex $move [lindex $m 0]]
      set str {}
      if {$adj < 0} {
	set str "[lindex $m 1]: $adj"
      } elseif {$adj > 0} {
	set str "[lindex $m 1]: +$adj"
      }
      if {[expr $ll + [string length $str]] > 79} {
	.encumbrences.frame.text2 insert end "\n$indent"
	set ll [string length $indent]
      }
      .encumbrences.frame.text2 insert end "$str"
      incr ll [string length $str]
    }
    .encumbrences.frame.text2 insert end "\n"
  }


# end of widget tree


  }
}


# Procedure: MasterRemoveCharacter
proc MasterRemoveCharacter {} {
  global CurrentMasterGame
  if {$CurrentMasterGame(handle) == {}} {return}
  if {[selection own] == [SN MasterCharacterList]} {
    set line [GetSelection]
    if {$line == {}} {return}
    set newList [lindex [split $line] 0]
    set handle [$newList handle]
    set i [CLFind [SN MasterCharacterList] $line]
    set head [$CurrentMasterGame(handle) players]
    if {$head == $newList} {
      $CurrentMasterGame(handle) players [$head nextcharacter]
      set CurrentMasterGame(isdirty) 1
    } else {
      while {[$head nextcharacter] != $newList && [$head nextcharacter] != {}} {
	set head [$head nextcharacter]
      }
      if {[$head nextcharacter] == $newList} {
	$head nextcharacter [$newList nextcharacter]
	set CurrentMasterGame(isdirty) 1
      }
    }
    catch [list $newList delete]
    catch [list CLDelete [SN MasterCharacterList] $i]
    global CurrentCharacter
    if {$CurrentCharacter(handle) != $handle} {
      catch [list $handle delete]
    }
    MasterRemoveMarchIcon $newList
  }
}


# Procedure: MasterAddCombatant
proc MasterAddCombatant {} {
  if {[selection own] == [SN MasterCharacterList]} {
    set line [GetSelection]
    if {$line == {}} {return}
    set list [lindex [split $line] 0]
    set handle [$list handle]
    set name [$handle name]
    set hp [$list hitpoints]
    set bm [$list bitmap]
    set newline "$list - $name $hp"
    CLInsert [SN MasterMeleeCombatants] end $bm $newline
  } elseif {[selection own] == [SN MasterMonstersList]} {
    set line [GetSelection]
    if {$line == {}} {return}
    set list [lindex [split $line] 0]
    set handle [$list handle]
    set name [$handle name]
    set hp [$list hitpoints]
    set bm [$list bitmap]
    set newline "$list - $name $hp"
    CLInsert [SN MasterMeleeCombatants] end $bm $newline
  }
}


# Procedure: MasterGoto
proc MasterGoto {} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  set level [[SN MasterLocationLevel] get]
  set x [[SN MasterLocationX] get]
  set y [[SN MasterLocationY] get]
  if {[catch "expr int($level)" result]} {
    error "Level not an integer: $result"
  }
  if {[catch "expr int($x)" result]} {
    error "X not an integer: $result"
  }
  if {[catch "expr int($y)" result]} {
    error "Y not an integer: $result"
  }
  if {$level < 0} {
    error "Level negative!"
  }
  if {$x < 0} {
    error "X negative!"
  }
  if {$y < 0} {
    error "Y negative!"
  }
  set levels [$CurrentMasterDungeon(handle) levels]
  set xsize  [$CurrentMasterDungeon(handle) xsize]
  set ysize  [$CurrentMasterDungeon(handle) ysize]
  if {$level >= $levels} {
    error "Level too large - >= $levels"
  }
  if {$x >= $xsize} {
    error "X too large - >= $xsize"
  }
  if {$y >= $ysize} {
    error "Y too large - >= $ysize"
  }
  set CurrentMasterDungeon(level) $level
  set CurrentMasterDungeon(x) $x
  set CurrentMasterDungeon(y) $y
  UpdateSpaceForm
}


# Procedure: MasterMeleeDamage
proc MasterMeleeDamage {} {
  global MasterMeleeAttacker
  global MasterMeleeDefender
  if {$MasterMeleeAttacker == {} || $MasterMeleeDefender == {}} {return}
  set nd [[SN MasterMeleeDamageND] get]
  set ns [[SN MasterMeleeDamageNS] get]
  if {![IsPosInteger $nd]} {
    AlertBox "Bad number of damage dice: $nd"
    [SN MasterMeleeDamageND] delete 0 end
    [SN MasterMeleeDamageND] insert end {1}
    return
  }
  if {![IsPosInteger $ns]} {
    AlertBox "Bad number of damage die sides: $ns"
    [SN MasterMeleeDamageNS] delete 0 end
    [SN MasterMeleeDamageNS] insert end {6}
    return
  }
  set dice [Dice $ns $nd]
  set roll [$dice roll]
  $dice delete
  set adjustments [InputBoxOne "Damage Adjustments? "]
  if {$adjustments != {}} {
    if {![IsInteger $adjustments]} {
      AlertBox "Bad adjustment: $adjustments, ignored"
      set adjustments {}
    } else {
      if {[string index $adjustments 0] == "+"} {
	set adjustments [string range $adjustments 1 end]
      }
      set roll [expr $roll + $adjustments]
    }
  }
  [SN MasterMeleeDamageValue] configure -text "$roll"
  set def [CLGet [SN MasterMeleeCombatants] $MasterMeleeDefender]
  set hp 100
  foreach x $def {
    if {[[SN MasterMeleeCombatants] type $x] == "text"} {
      set line [lindex [[SN MasterMeleeCombatants] itemconfig $x -text] 4]
      set list [lindex [split $line " "] 0]
      set handle [$list handle]
      set name [$handle name]
      set oldhp [$list hitpoints]
      set hp [expr $oldhp - $roll]
      $list hitpoints $hp
      global CurrentMasterGame
      set CurrentMasterGame(isdirty) 1
      set line "$list - $name $hp"
      [SN MasterMeleeCombatants] itemconfig $x -text "$line"
    }
  }
  if {$hp <= 0} {
    CLDelete [SN MasterMeleeCombatants] $MasterMeleeDefender
    set MasterMeleeDefender {}
  }
  focus [SN MasterMeleeHitND]
}


# Procedure: MasterMeleeHit
proc MasterMeleeHit {} {
  global MasterMeleeAttacker
  global MasterMeleeDefender
  if {$MasterMeleeAttacker == {} || $MasterMeleeDefender == {}} {return}
  set nd [[SN MasterMeleeHitND] get]
  set ns [[SN MasterMeleeHitNS] get]
  if {![IsPosInteger $nd]} {
    AlertBox "Bad number of hit dice: $nd"
    [SN MasterMeleeHitND] delete 0 end
    [SN MasterMeleeHitND] insert end {1}
    return
  }
  if {![IsPosInteger $ns]} {
    AlertBox "Bad number of hit die sides: $ns"
    [SN MasterMeleeHitNS] delete 0 end
    [SN MasterMeleeHitNS] insert end {6}
    return
  }
  set dice [Dice $ns $nd]
  set roll [$dice roll]
  $dice delete
  set adjustments [InputBoxOne "To Hit Adjustments? "]
  if {$adjustments != {}} {
    if {![IsInteger $adjustments]} {
      AlertBox "Bad adjustment: $adjustments, ignored"
      set adjustments {}
    } else {
      if {[string index $adjustments 0] == "+"} {
	set adjustments [string range $adjustments 1 end]
      }
      set roll [expr $roll + $adjustments]
    }
  }
  [SN MasterMeleeHitValue] configure -text "$roll"
  focus [SN MasterMeleeDamageND]
}


# Procedure: MasterNextMeleeRound
proc MasterNextMeleeRound {} {
  set round [lindex [[SN MasterCurrentMeleeRound] configure -text] 4]
  incr round
  [SN MasterCurrentMeleeRound] configure -text $round
  global MasterMeleeAttacker
  global MasterMeleeDefender
  if {$MasterMeleeAttacker != {}} {
    set oldatt [CLGet [SN MasterMeleeCombatants] $MasterMeleeAttacker]
    foreach x $oldatt {
      if {[[SN MasterMeleeCombatants] type $x] == "bitmap"} {
        [SN MasterMeleeCombatants] itemconfig $x -foreground black
      }
    }
    set MasterMeleeAttacker {}
  }
  if {$MasterMeleeDefender != {}} {
    set oldatt [CLGet [SN MasterMeleeCombatants] $MasterMeleeDefender]
    foreach x $oldatt {
      if {[[SN MasterMeleeCombatants] type $x] == "bitmap"} {
        [SN MasterMeleeCombatants] itemconfig $x -foreground black
      }
    }
    set MasterMeleeDefender {}
  }
}


# Procedure: MasterSelectAttacker
proc MasterSelectAttacker {} {
  if {[selection own] == [SN MasterMeleeCombatants]} {
    set line [GetSelection]
    if {$line == {}} {return}
    set i [CLFind [SN MasterMeleeCombatants] $line]
    global MasterMeleeAttacker
    if {$MasterMeleeAttacker != {}} {
      set oldatt [CLGet [SN MasterMeleeCombatants] $MasterMeleeAttacker]
      foreach x $oldatt {
        if {[[SN MasterMeleeCombatants] type $x] == "bitmap"} {
	  [SN MasterMeleeCombatants] itemconfig $x -foreground black
	}
      }
    }
    set MasterMeleeAttacker $i
    set att [CLGet [SN MasterMeleeCombatants] $MasterMeleeAttacker]
    foreach x $att {
      if {[[SN MasterMeleeCombatants] type $x] == "bitmap"} {
	[SN MasterMeleeCombatants] itemconfig $x -foreground red
      }
    }
  }
}


# Procedure: MasterSelectDefender
proc MasterSelectDefender {} {
  if {[selection own] == [SN MasterMeleeCombatants]} {
    set line [GetSelection]
    if {$line == {}} {return}
    set i [CLFind [SN MasterMeleeCombatants] $line]
    global MasterMeleeDefender
    if {$MasterMeleeDefender != {}} {
      set oldatt [CLGet [SN MasterMeleeCombatants] $MasterMeleeDefender]
      foreach x $oldatt {
        if {[[SN MasterMeleeCombatants] type $x] == "bitmap"} {
	  [SN MasterMeleeCombatants] itemconfig $x -foreground black
	}
      }
    }
    set MasterMeleeDefender $i
    set att [CLGet [SN MasterMeleeCombatants] $MasterMeleeDefender]
    foreach x $att {
      if {[[SN MasterMeleeCombatants] type $x] == "bitmap"} {
	[SN MasterMeleeCombatants] itemconfig $x -foreground green
      }
    }
  }
}


# Procedure: MasterViewCharacter
proc MasterViewCharacter {} {
  if {[selection own] == [SN MasterCharacterList]} {
    set line [GetSelection]
    if {$line == {}} {return}
    set list [lindex [split $line] 0]
    set handle [$list handle]
    global CurrentCharacter
    if {$CurrentCharacter(handle) != {}} {
      if {$CurrentCharacter(isdirty)} {
	set answer [YesNoBox "Modified character data in character frame, lose it?"]
	if {!$answer} {
	    return
	}
      }
      $CurrentCharacter(handle) delete
      set CurrentCharacter(handle) {}
      set CurrentCharacter(isdirty) 0
      set CurrentCharacter(filename) {}
      ResetCharacterForm
    }
    set charfile [$list file]
    set CurrentCharacter(handle) [Character]
    $CurrentCharacter(handle) read $charfile
    set CurrentCharacter(isdirty) 0
    set CurrentCharacter(filename) $charfile
    ResetCharacterForm
    PopFrame CharacterFrame
  }
}


# Procedure: MasterInsertMarchIcon
proc MasterInsertMarchIcon { bm iconTag line} {
  set canvas [SN MasterMarchCanvas]
  $canvas create bitmap 0 0 -bitmap $bm -anchor nw -tag $iconTag
  set bbox [$canvas bbox $iconTag]
  $canvas delete $iconTag
  set xsize [expr [lindex $bbox 2] + 4]
  set ysize [expr [lindex $bbox 3] + 4]
  set sr [lindex [$canvas configure -scrollregion] 4]
  if {$sr == {}} {
    set sr {0 0 150 300}
    $canvas configure -scrollregion $sr
  }
  set startx [expr [lindex $sr 0] + 6]
  set starty [expr [lindex $sr 1] + 6]
  set endx [expr [lindex $sr 2] - 6]
  set endy [expr [lindex $sr 3] - 6]
  for {set y $starty} {$y < $endy} {incr y $ysize} {
    for {set x $startx} {$x < $endx} {incr x $xsize} {
      set occupued [expr [llength [$canvas find overlapping $x $y [expr $x + 60] [expr $y + 70]]] > 0]
      if {! $occupued } break
    }
    if {! $occupued } break
  }
  $canvas create bitmap $x $y -bitmap $bm -anchor nw -tag $iconTag
  $canvas bind $iconTag <Button-2> "MasterIconSelect [SN MasterCharacterList] \"$line\""
}


# Procedure: MasterRemoveMarchIcon
proc MasterRemoveMarchIcon { iconTag} {
  set canvas [SN MasterMarchCanvas]
  $canvas delete $iconTag
}


# Procedure: MasterIconSelect
proc MasterIconSelect {CL selectText} {
  set i [CLFind $CL $selectText]
  set items [CLGet $CL $i]
  set tag {}
  foreach x $items {
    if {[$CL type $x] == "text" } {
      set tag $x
      break
    }
  }
  if {$tag == {}} {
    return
  }
  $CL select from $tag 0
  $CL select to $tag end
}


# Procedure: MasterAddTrick
proc MasterAddTrick {} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  set space [$CurrentMasterDungeon(handle) space $CurrentMasterDungeon(level) $CurrentMasterDungeon(x) $CurrentMasterDungeon(y)]
  if {$space == {}} {
    return
  }
  set listelt [GetTrickTreasure "Trick" mastertricklist]
  if {$listelt == {}} {return}
  set handle [$listelt handle]
  global fsBox
  set fsBox(showPixmap) 1
  set fsBox(pattern) {*.xbm*}
  set bm [FSBox "Select trick bitmap: "]
  set fsBox(showPixmap) 0
  if {$bm == ""} {  
    set bm error
  } else {
    set file [string range $bm 1 end]
    if {![file exists $file]} {
      set bm error
    } else {
      if {[catch [list [SN MasterMarchCanvas] create bitmap 0 0 -bitmap $bm] \
		 tag] == 0} {
	[SN MasterMarchCanvas] delete $tag
	set bm "@[TrimPathPrefix $file]"
      } else {
	set bm error
      }
    }
  }
  set canvas [SN MasterSpace00]
  set newList [TrickList [$handle name] $bm $handle [$space tricks] 0 0 0 1] 
  $space tricks $newList
  set CurrentMasterDungeon(isdirty) 1
  $canvas create bitmap 0 0 -bitmap $bm -anchor nw -tags $newList
  set line "$newList - ($handle) - [$handle name]"
  CLInsert [SN MasterTrickList] end $bm $line
  $canvas bind $newList <Button-2> "MasterIconSelect [SN MasterTrickList] \"$line\""
}


# Procedure: MasterRemoveTrick
proc MasterRemoveTrick {} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  set space [$CurrentMasterDungeon(handle) space $CurrentMasterDungeon(level) $CurrentMasterDungeon(x) $CurrentMasterDungeon(y)]
  if {$space == {}} {
    return
  }
  if {[selection own] == [SN MasterTrickList]} {
    set line [GetSelection]
    if {$line == {}} {return}
    set newList [lindex [split $line] 0]
    set i [CLFind [SN MasterTrickList] $line]
    set head [$space tricks]
    if {$head == $newList} {
      $space tricks [$head nexttrick]
      set CurrentMasterDungeon(isdirty) 1
    } else {
      while {[$head nexttrick] != $newList && [$head nexttrick] != {}} {
        set head [$head nexttrick]
      }
      if {[$head nexttrick] == $newList} {
	$head nexttrick [$newList nexttrick]
	set CurrentMasterDungeon(isdirty) 1
      }
    }
    catch [list $newList delete]
    catch [list CLDelete [SN MasterTrickList] $i]
    catch [list [SN MasterSpace00] delete $newList] 
  }
}


# Procedure: MasterViewTrick
proc MasterViewTrick {} {
  if {[selection own] == [SN MasterTrickList]} {
    set line [GetSelection]
    if {$line == {}} {return}
    set listelt [lindex [split $line] 0]
    set handle [$listelt handle]

  # build widget .viewTrick
  if {"[info procs XFEdit]" != ""} {
    catch "XFDestroy .viewTrick"
  } {
    catch "destroy .viewTrick"
  }
  toplevel .viewTrick 

  # Window manager configurations
  global tkVersion
  wm positionfrom .viewTrick ""
  wm sizefrom .viewTrick program
  wm maxsize .viewTrick 1000 768
  wm minsize .viewTrick 10 10
  wm title .viewTrick "Trick: $handle"


  # build widget .viewTrick.description
  frame .viewTrick.description \
    -borderwidth {2}

  # build widget .viewTrick.description.description
  label .viewTrick.description.description \
    -relief {sunken}\
    -text "[$handle description]"\
    -width {60}\
    -anchor w

  # build widget .viewTrick.description.label12
  label .viewTrick.description.label12 \
    -text {Description:}

  # pack widget .viewTrick.description
  pack append .viewTrick.description \
    .viewTrick.description.label12 {left frame center} \
    .viewTrick.description.description {left frame w expand fillx} 

  # build widget .viewTrick.name
  frame .viewTrick.name \
    -borderwidth {2}

  # build widget .viewTrick.name.label8
  label .viewTrick.name.label8 \
    -text {Name:}

  # build widget .viewTrick.name.name
  label .viewTrick.name.name \
    -relief {sunken}\
    -text "[$handle name]"\
    -anchor w

  # pack widget .viewTrick.name
  pack append .viewTrick.name \
    .viewTrick.name.label8 {left frame center} \
    .viewTrick.name.name {left frame w expand fillx} 

  # build widget .viewTrick.ok
  button .viewTrick.ok \
    -text {Ok}\
    -command {if {"[info procs XFEdit]" != ""} {
  catch "XFDestroy .viewTrick"
} {
  catch "destroy .viewTrick"
}}


  # build widget .viewTrick.type
  frame .viewTrick.type \
    -borderwidth {2}

  # build widget .viewTrick.type.label10
  label .viewTrick.type.label10 \
    -text {Type:}

  # build widget .viewTrick.type.type
  label .viewTrick.type.type \
    -relief {sunken}\
    -text "[$handle tricktype]"\
    -anchor w

  # pack widget .viewTrick.type
  pack append .viewTrick.type \
    .viewTrick.type.label10 {left frame center} \
    .viewTrick.type.type {left frame w expand fillx} 

  # build widget .viewTrick.activeP
  frame .viewTrick.activeP \
    -borderwidth {2}

  # build widget .viewTrick.activeP.label18
  label .viewTrick.activeP.label18 \
    -text {Active? }

  # build widget .viewTrick.activeP.active
  label .viewTrick.activeP.active \
    -relief {sunken}

  if {[$listelt active]} {
    .viewTrick.activeP.active configure -text {Yes}
  } else {
    .viewTrick.activeP.active configure -text {No}
  }

  # pack widget .viewTrick.activeP
  pack append .viewTrick.activeP \
    .viewTrick.activeP.label18 {left frame center} \
    .viewTrick.activeP.active {left frame w}

  # pack widget .viewTrick
  pack append .viewTrick \
    .viewTrick.name {top frame center fillx} \
    .viewTrick.type {top frame center fillx} \
    .viewTrick.description {top frame center fillx} \
    .viewTrick.activeP {top frame center fillx} \
    .viewTrick.ok {top frame center fillx}

# end of widget tree
  }
}


# Procedure: MasterAddOther
proc MasterAddOther {} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  set space [$CurrentMasterDungeon(handle) space $CurrentMasterDungeon(level) $CurrentMasterDungeon(x) $CurrentMasterDungeon(y)]
  if {$space == {}} {
    return
  }

  # build widget .newDressing
  if {"[info procs XFEdit]" != ""} {
    catch "XFDestroy .newDressing"
  } {
    catch "destroy .newDressing"
  }
  toplevel .newDressing 

  # Window manager configurations
  global tkVersion
  wm positionfrom .newDressing ""
  wm sizefrom .newDressing program
  wm maxsize .newDressing 1000 768
  wm minsize .newDressing 10 10
  wm title .newDressing {New Dressing}


  # build widget .newDressing.bitmap
  frame .newDressing.bitmap \
    -borderwidth {2}

  # build widget .newDressing.bitmap.bitmap
  entry .newDressing.bitmap.bitmap \
    -relief {sunken}
  # bindings
  bind .newDressing.bitmap.bitmap <Key-Return> {focus .newDressing.description.description}
  bind .newDressing.bitmap.bitmap <Key-Tab> {focus .newDressing.description.description}

  # build widget .newDressing.bitmap.button10
  button .newDressing.bitmap.button10 \
    -command {global fsBox
set fsBox(showPixmap) 1
set fsBox(pattern) {*.xbm}
set bm [FSBox "Select Bitmap: " [.newDressing.bitmap.bitmap get]]
set fsBox(showPixmap) 0
if {$bm != {}} {
  .newDressing.bitmap.bitmap delete 0 end
  .newDressing.bitmap.bitmap insert end "$bm"
}}\
    -text {Browse}

  # build widget .newDressing.bitmap.label8
  label .newDressing.bitmap.label8 \
    -text {Bitmap: }

  # pack widget .newDressing.bitmap
  pack append .newDressing.bitmap \
    .newDressing.bitmap.label8 {left frame center} \
    .newDressing.bitmap.bitmap {left frame center expand fillx} \
    .newDressing.bitmap.button10 {right frame center} 

  # build widget .newDressing.buttons
  frame .newDressing.buttons \
    -borderwidth {2}

  # build widget .newDressing.buttons.cancel
  button .newDressing.buttons.cancel \
    -text {Cancel}\
    -command {if {"[info procs XFEdit]" != ""} {
    catch "XFDestroy .newDressing"
  } {
    catch "destroy .newDressing"
  }}

  # build widget .newDressing.buttons.ok
  button .newDressing.buttons.ok \
    -text {OK}\
    -command {MasterAddOtherOK}

  # build widget .newDressing.buttons.help
  button .newDressing.buttons.help \
    -text {Help}\
    -command {PopupHelpTopic NewDressing}

  # pack widget .newDressing.buttons
  pack append .newDressing.buttons \
    .newDressing.buttons.ok {left frame center expand} \
    .newDressing.buttons.cancel {left frame center expand} \
    .newDressing.buttons.help {right frame center expand} 

  # build widget .newDressing.description
  frame .newDressing.description \
    -borderwidth {2}

  # build widget .newDressing.description.description
  entry .newDressing.description.description \
    -relief {sunken}\
    -width {60}
  # bindings
  bind .newDressing.description.description <Key-Return> {focus .newDressing.value.value}
  bind .newDressing.description.description <Key-Tab> {focus .newDressing.value.value}

  # build widget .newDressing.description.label11
  label .newDressing.description.label11 \
    -text {Description: }

  # pack widget .newDressing.description
  pack append .newDressing.description \
    .newDressing.description.label11 {left frame center} \
    .newDressing.description.description {left frame center expand fillx} 

  # build widget .newDressing.name
  frame .newDressing.name \
    -borderwidth {2}

  # build widget .newDressing.name.label6
  label .newDressing.name.label6 \
    -text {Name: }

  # build widget .newDressing.name.name
  entry .newDressing.name.name \
    -relief {sunken}
  # bindings
  bind .newDressing.name.name <Key-Return> {focus .newDressing.bitmap.bitmap}
  bind .newDressing.name.name <Key-Tab> {focus .newDressing.bitmap.bitmap}

  # pack widget .newDressing.name
  pack append .newDressing.name \
    .newDressing.name.label6 {left frame center} \
    .newDressing.name.name {left frame center expand fillx} 

  # build widget .newDressing.value
  frame .newDressing.value \
    -borderwidth {2}

  # build widget .newDressing.value.label13
  label .newDressing.value.label13 \
    -text {Value: }

  # build widget .newDressing.value.value
  entry .newDressing.value.value \
    -relief {sunken}
  # bindings
  bind .newDressing.value.value <Key-Return> {focus .newDressing.name.name}
  bind .newDressing.value.value <Key-Tab> {focus .newDressing.name.name}

  # pack widget .newDressing.value
  pack append .newDressing.value \
    .newDressing.value.label13 {left frame center} \
    .newDressing.value.value {left frame center} 

  # pack widget .newDressing
  pack append .newDressing \
    .newDressing.name {top frame center fillx} \
    .newDressing.bitmap {top frame center fillx} \
    .newDressing.description {top frame center fillx} \
    .newDressing.value {top frame center fillx} \
    .newDressing.buttons {top frame center fillx} 

  .newDressing.bitmap.bitmap insert end {}
  .newDressing.description.description insert end {}
  .newDressing.name.name insert end {}
  .newDressing.value.value insert end {0}

  focus .newDressing.name.name
# end of widget tree

  update idletasks
  grab .newDressing
  tkwait window .newDressing
}

# Procedure: MasterAddOtherOK
proc MasterAddOtherOK {} {
  set value [.newDressing.value.value get]
  if {[catch "expr int($value)" err]} {
    AlertBox "Bad value: $value -- $err"
    return
  }
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  set space [$CurrentMasterDungeon(handle) space $CurrentMasterDungeon(level) $CurrentMasterDungeon(x) $CurrentMasterDungeon(y)]
  set bm [.newDressing.bitmap.bitmap get]
  if {$bm == ""} {
    set bm hourglass
  } else {
    set file [string range $bm 1 end]
    if {![file exists $file]} {
      set bm hourglass
    } else {
      if {[catch [list [SN MasterMarchCanvas] create bitmap 0 0 -bitmap $bm] \
		 tag] == 0} {
	[SN MasterMarchCanvas] delete $tag
	set bm "@[TrimPathPrefix $file]"
      } else {
	set bm hourglass
      }
    }
  }
  set canvas [SN MasterSpace00] 
  set newList [DressingList [.newDressing.name.name get] $bm \
			    [.newDressing.description.description get] \
			    [$space dressings] 0 0 $value]
  if {"[info procs XFEdit]" != ""} {
    catch "XFDestroy .newDressing"
  } {
    catch "destroy .newDressing"
  }
  $space dressings $newList
  set CurrentMasterDungeon(isdirty) 1
  $canvas create bitmap 0 0 -bitmap $bm -anchor nw -tags $newList
  set line "$newList - [$newList name] - [$newList description]"
  CLInsert [SN MasterOtherList] end $bm $line
  $canvas bind $newList <Button-2> "MasterIconSelect [SN MasterOtherList] \"$line\""
}	    

# Procedure: MasterRemoveOther
proc MasterRemoveOther {} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  set space [$CurrentMasterDungeon(handle) space $CurrentMasterDungeon(level) $CurrentMasterDungeon(x) $CurrentMasterDungeon(y)]
  if {$space == {}} {
    return
  }
  if {[selection own] == [SN MasterOtherList]} {
    set line [GetSelection]
    if {$line == {}} {return}
    set newList [lindex [split $line] 0]
    set i [CLFind [SN MasterOtherList] $line]
    set head [$space dressings]
    if {$head == $newList} {
      $space dressings [$head nextdressing]
      set CurrentMasterDungeon(isdirty) 1
    } else {
      while {[$head nextdressing] != $newList && [$head nextdressing] != {}} {
        set head [$head nextdressing]
      }
      if {[$head nextdressing] == $newList} {
	$head nextdressing [$newList nextdressing]
	set CurrentMasterDungeon(isdirty) 1
      }
    }
    catch [list $newList delete]
    catch [list CLDelete [SN MasterDressingList] $i]
    catch [list [SN MasterSpace00] delete $newList] 
  }
}


# Procedure: MasterViewOther
proc MasterViewOther {} {
  if {[selection own] == [SN MasterOtherList]} {
    set line [GetSelection]
    if {$line == {}} {return}
    set listelt [lindex [split $line] 0]

  # build widget .viewDressing
  if {"[info procs XFEdit]" != ""} {
    catch "XFDestroy .viewDressing"
  } {
    catch "destroy .viewDressing"
  }
  toplevel .viewDressing 

  # Window manager configurations
  global tkVersion
  wm positionfrom .viewDressing ""
  wm sizefrom .viewDressing program
  wm maxsize .viewDressing 1000 768
  wm minsize .viewDressing 10 10
  wm title .viewDressing "Other: [$listelt name]"


  # build widget .viewDressing.description
  frame .viewDressing.description \
    -borderwidth {2}

  # build widget .viewDressing.description.description
  label .viewDressing.description.description \
    -anchor {w}\
    -relief {sunken}\
    -text "[$listelt description]"\
    -width {60}

  # build widget .viewDressing.description.label24
  label .viewDressing.description.label24 \
    -text {Description:}

  # pack widget .viewDressing.description
  pack append .viewDressing.description \
    .viewDressing.description.label24 {left frame center} \
    .viewDressing.description.description {top frame center expand fillx} 

  # build widget .viewDressing.name
  frame .viewDressing.name \
    -borderwidth {2}

  # build widget .viewDressing.name.label22
  label .viewDressing.name.label22 \
    -text {Name:}

  # build widget .viewDressing.name.name
  label .viewDressing.name.name \
    -anchor {w}\
    -relief {sunken}\
    -text "[$listelt name]"

  # pack widget .viewDressing.name
  pack append .viewDressing.name \
    .viewDressing.name.label22 {left frame center} \
    .viewDressing.name.name {left frame center expand fillx} 

  # build widget .viewDressing.ok
  button .viewDressing.ok \
    -text {OK}\
    -command {if {"[info procs XFEdit]" != ""} {
  catch "XFDestroy .viewDressing"
} {
  catch "destroy .viewDressing"
}}

  # build widget .viewDressing.value
  frame .viewDressing.value \
    -borderwidth {2}

  # build widget .viewDressing.value.label26
  label .viewDressing.value.label26 \
    -text {Value:}

  # build widget .viewDressing.value.value
  label .viewDressing.value.value \
    -anchor {w}\
    -relief {sunken}\
    -text [$listelt value]\
    -width {9}

  # pack widget .viewDressing.value
  pack append .viewDressing.value \
    .viewDressing.value.label26 {left frame center} \
    .viewDressing.value.value {left frame center} 

  # pack widget .viewDressing
  pack append .viewDressing \
    .viewDressing.name {top frame center fillx} \
    .viewDressing.description {top frame center fillx} \
    .viewDressing.value {top frame center fillx} \
    .viewDressing.ok {top frame center fillx} 
# end of widget tree
  }
}


# Procedure: MasterAddTreasure
proc MasterAddTreasure {} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  set space [$CurrentMasterDungeon(handle) space $CurrentMasterDungeon(level) $CurrentMasterDungeon(x) $CurrentMasterDungeon(y)]
  if {$space == {}} {
    return
  }
  set listelt [GetTrickTreasure "Treasure" mastertreasurelist]
  if {$listelt == {}} {return}
  set handle [$listelt handle]
  global fsBox
  set fsBox(showPixmap) 1
  set fsBox(pattern) {*.xbm*}
  set bm [FSBox "Select treasure bitmap: "]
  set fsBox(showPixmap) 0
  if {$bm == ""} {  
    set bm warning
  } else {
    set file [string range $bm 1 end]
    if {![file exists $file]} {
      set bm warning
    } else {
      if {[catch [list [SN MasterMarchCanvas] create bitmap 0 0 -bitmap $bm] \
		 tag] == 0} {
	[SN MasterMarchCanvas] delete $tag
	set bm "@[TrimPathPrefix $file]"
      } else {
	set bm warning
      }
    }
  }
  set canvas [SN MasterSpace00]
  set newList [TreasureList [$handle name] $bm $handle [$space treasures] 0 0 \
		[$handle value]] 
  $space treasures $newList
  set CurrentMasterDungeon(isdirty) 1
  $canvas create bitmap 0 0 -bitmap $bm -anchor nw -tags $newList
  set line "$newList - ($handle) - [$handle name]"
  CLInsert [SN MasterTreasureList] end $bm $line
  $canvas bind $newList <Button-2> "MasterIconSelect [SN MasterTreasureList] \"$line\""
}


# Procedure: MasterRemoveTreasure
proc MasterRemoveTreasure {} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  set space [$CurrentMasterDungeon(handle) space $CurrentMasterDungeon(level) $CurrentMasterDungeon(x) $CurrentMasterDungeon(y)]
  if {$space == {}} {
    return
  }
  if {[selection own] == [SN MasterTreasureList]} {
    set line [GetSelection]
    if {$line == {}} {return}
    set newList [lindex [split $line] 0]
    set i [CLFind [SN MasterTreasureList] $line]
    set head [$space treasures]
    if {$head == $newList} {
      $space treasures [$head nexttreasure]
      set CurrentMasterDungeon(isdirty) 1
    } else {
      while {[$head nexttreasure] != $newList && [$head nexttreasure] != {}} {
        set head [$head nexttreasure]
      }
      if {[$head nexttreasure] == $newList} {
	$head nexttreasure [$newList nexttreasure]
	set CurrentMasterDungeon(isdirty) 1
      }
    }
    catch [list $newList delete]
    catch [list CLDelete [SN MasterTreasureList] $i]
    catch [list [SN MasterSpace00] delete $newList] 
  }
}


# Procedure: MasterViewTreasure
proc MasterViewTreasure {} {
  if {[selection own] == [SN MasterTreasureList]} {
    set line [GetSelection]
    if {$line == {}} {return}
    set listelt [lindex [split $line] 0]
    set handle [$listelt handle]

  # build widget .viewTreasure
  if {"[info procs XFEdit]" != ""} {
    catch "XFDestroy .viewTreasure"
  } {
    catch "destroy .viewTreasure"
  }
  toplevel .viewTreasure 

  # Window manager configurations
  global tkVersion
  wm positionfrom .viewTreasure ""
  wm sizefrom .viewTreasure program
  wm maxsize .viewTreasure 1000 768
  wm minsize .viewTreasure 10 10
  wm title .viewTreasure "Treasure: $handle"


  # build widget .viewTreasure.description
  frame .viewTreasure.description \
    -borderwidth {2}

  # build widget .viewTreasure.description.description
  label .viewTreasure.description.description \
    -relief {sunken}\
    -text "[$handle description]"\
    -width {60}\
    -anchor w

  # build widget .viewTreasure.description.label12
  label .viewTreasure.description.label12 \
    -text {Description:}

  # pack widget .viewTreasure.description
  pack append .viewTreasure.description \
    .viewTreasure.description.label12 {left frame center} \
    .viewTreasure.description.description {left frame w expand fillx} 

  # build widget .viewTreasure.epValue
  frame .viewTreasure.epValue \
    -borderwidth {2}

  # build widget .viewTreasure.epValue.epValue
  label .viewTreasure.epValue.epValue \
    -relief {sunken}\
    -text [$handle experiencepointvalue]\
    -width {9}\
    -anchor w

  # build widget .viewTreasure.epValue.label14
  label .viewTreasure.epValue.label14 \
    -text {Experience Point Value: }

  # pack widget .viewTreasure.epValue
  pack append .viewTreasure.epValue \
    .viewTreasure.epValue.label14 {left frame center} \
    .viewTreasure.epValue.epValue {left frame w} 

  # build widget .viewTreasure.name
  frame .viewTreasure.name \
    -borderwidth {2}

  # build widget .viewTreasure.name.label8
  label .viewTreasure.name.label8 \
    -text {Name:}

  # build widget .viewTreasure.name.name
  label .viewTreasure.name.name \
    -relief {sunken}\
    -text "[$handle name]"\
    -anchor w

  # pack widget .viewTreasure.name
  pack append .viewTreasure.name \
    .viewTreasure.name.label8 {left frame center} \
    .viewTreasure.name.name {left frame w expand fillx} 

  # build widget .viewTreasure.ok
  button .viewTreasure.ok \
    -text {Ok}\
    -command {if {"[info procs XFEdit]" != ""} {
  catch "XFDestroy .viewTreasure"
} {
  catch "destroy .viewTreasure"
}}

  # build widget .viewTreasure.type
  frame .viewTreasure.type \
    -borderwidth {2}

  # build widget .viewTreasure.type.label10
  label .viewTreasure.type.label10 \
    -text {Type:}

  # build widget .viewTreasure.type.type
  label .viewTreasure.type.type \
    -relief {sunken}\
    -text "[$handle treasuretype]"\
    -anchor w

  # pack widget .viewTreasure.type
  pack append .viewTreasure.type \
    .viewTreasure.type.label10 {left frame center} \
    .viewTreasure.type.type {left frame w expand fillx} 

  # build widget .viewTreasure.uniqueP
  frame .viewTreasure.uniqueP \
    -borderwidth {2}

  # build widget .viewTreasure.uniqueP.label18
  label .viewTreasure.uniqueP.label18 \
    -text {Unique? }

  # build widget .viewTreasure.uniqueP.unique
  label .viewTreasure.uniqueP.unique \
    -relief {sunken}

  if {[$handle unique]} {
    .viewTreasure.uniqueP.unique configure -text {Yes}
  } else {
    .viewTreasure.uniqueP.unique configure -text {No}
  }


  # pack widget .viewTreasure.uniqueP
  pack append .viewTreasure.uniqueP \
    .viewTreasure.uniqueP.label18 {left frame center} \
    .viewTreasure.uniqueP.unique {left frame w} 

  # build widget .viewTreasure.value
  frame .viewTreasure.value \
    -borderwidth {2}

  # build widget .viewTreasure.value.label16
  label .viewTreasure.value.label16 \
    -text {Value: }

  # build widget .viewTreasure.value.value
  label .viewTreasure.value.value \
    -relief {sunken}\
    -text [$handle value]\
    -width {9}\
    -anchor w

  # pack widget .viewTreasure.value
  pack append .viewTreasure.value \
    .viewTreasure.value.label16 {left frame center} \
    .viewTreasure.value.value {left frame w} 

  # pack widget .viewTreasure
  pack append .viewTreasure \
    .viewTreasure.name {top frame center fillx} \
    .viewTreasure.type {top frame center fillx} \
    .viewTreasure.description {top frame center fillx} \
    .viewTreasure.epValue {top frame center fillx} \
    .viewTreasure.value {top frame center fillx} \
    .viewTreasure.uniqueP {top frame center fillx} \
    .viewTreasure.ok {top frame center fillx} 
# end of widget tree
  }
}


# Procedure: MasterAddMonster
proc MasterAddMonster {} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  set space [$CurrentMasterDungeon(handle) space $CurrentMasterDungeon(level) $CurrentMasterDungeon(x) $CurrentMasterDungeon(y)]
  if {$space == {}} {
    return
  }
  set listelt [GetMonsterOrNPC]
  if {$listelt == {}} {return}
  set handle [$listelt handle]
  set bm     [$listelt bitmap]
  set monsterfile [$listelt file]
  set canvas [SN MasterSpace00]
  set newList [MonsterList $handle $monsterfile $bm {} 0 0 0]
  if {[$handle type] == "Character"} {
    $newList hitpoints [$handle hitpoints]
  } elseif {[$handle hittype] == "Points"} {
    $newList hitpoints [$handle hitpoints]
  } else {
    set hd [Dice [$handle hitdie] [$handle numhitdie]]
    $newList hitpoints [$hd roll]
    $hd delete
  }
  $newList nextmonster [$space monsters]
  $space monsters $newList
  set CurrentMasterDungeon(isdirty) 1
  $canvas create bitmap 0 0 -bitmap $bm -anchor nw -tags $newList
  set line "$newList - ($handle) - [$handle name]"
  CLInsert [SN MasterMonstersList] end $bm $line
  $canvas bind $newList <Button-2> "MasterIconSelect [SN MasterMonstersList] \"$line\""
}


# Procedure: MasterRemoveMonster
proc MasterRemoveMonster {} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  set space [$CurrentMasterDungeon(handle) space $CurrentMasterDungeon(level) $CurrentMasterDungeon(x) $CurrentMasterDungeon(y)]
  if {$space == {}} {
    return
  }
  if {[selection own] == [SN MasterMonstersList]} {
    set line [GetSelection]
    if {$line == {}} {return}
    set newList [lindex [split $line] 0]
    set handle [$newList handle]
    set i [CLFind [SN MasterMonstersList] $line]
    set head [$space monsters]
    if {$head == $newList} {
      $space monsters [$head nextmonster]
      set CurrentMasterDungeon(isdirty) 1
    } else {
      while {[$head nextmonster] != $newList && [$head nextmonster] != {}} {
	set head [$head nextmonster]
      }
      if {[$head nextmonster] == $newList} {
	$head nextmonster [$newList nextmonster]
	set CurrentMasterDungeon(isdirty) 1
      }
    }
    catch [list $newList delete]
    catch [list CLDelete [SN MasterMonstersList] $i]
    catch [list [SN MasterSpace00] delete $newList]
  }
}

# Procedure: MasterCreateMonster
proc MasterCreateMonster {} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  global fsBox
  set fsBox(pattern) {*.monster*}
  set fsBox(showPixmap) 0
  set monstfile [FSBox "Select monster file: "]
  if {$monstfile == ""} {
    return
  }
  if {![file exists $monstfile]} {
    return
  }
  set monstfile [TrimPathPrefix $monstfile]
  set handle [Monster]
  if {[catch [list $handle read $monstfile] error] != 0} {
    $handle delete
    return
  }
  set fsBox(showPixmap) 1
  set fsBox(pattern) {*.xbm*}
  set bm [FSBox "Select monster bitmap: "]
  set fsBox(showPixmap) 0
  if {$bm == ""} {
    set bm question
  } else {
    set file [string range $bm 1 end]
    if {![file exists $file]} {
      set bm question
    } else {
      if {[catch [list [SN MasterMarchCanvas] create bitmap 0 0 -bitmap $bm] tag] == 0} {
	[SN MasterMarchCanvas] delete $tag
	set bm "@[TrimPathPrefix $file]"
      } else {
	set bm question
      }
    }
  }
  set newList [MonsterList $handle $monstfile $bm \
		[$CurrentMasterDungeon(handle) mastermonsterlist] 0 0 0]
  $CurrentMasterDungeon(handle) mastermonsterlist $newList
  set CurrentMasterDungeon(isdirty) 1
}

# Procedure: MasterCreateNPC
proc MasterCreateNPC {} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  global fsBox
  set fsBox(pattern) {*.character*}
  set fsBox(showPixmap) 0
  set charfile [FSBox "Select character file: "]
  if {$charfile == ""} {
    return
  }
  if {![file exists $charfile]} {
    return
  }
  set charfile [TrimPathPrefix $charfile]
  set handle [Character]
  if {[catch [list $handle read $charfile] error] != 0} {
    $handle delete
    return
  }
  set fsBox(showPixmap) 1
  set fsBox(pattern) {*.xbm*}
  set bm [FSBox "Select character bitmap: "]
  set fsBox(showPixmap) 0
  if {$bm == ""} {
    set bm questhead
  } else {
    set file [string range $bm 1 end]
    if {![file exists $file]} {
      set bm questhead
    } else {
      if {[catch [list [SN MasterMarchCanvas] create bitmap 0 0 -bitmap $bm] tag] == 0} {
	[SN MasterMarchCanvas] delete $tag
	set bm "@[TrimPathPrefix $file]"
      } else {
	set bm questhead
      }
    }
  }
  set newList [CharacterList $handle $charfile $bm \
		[$CurrentMasterDungeon(handle) npclist] 0 0 {} 0]
  $CurrentMasterDungeon(handle) npclist $newList
  set CurrentMasterDungeon(isdirty) 1
}


# Procedure: MasterViewMonster
proc MasterViewMonster {} {
  if {[selection own] == [SN MasterMonstersList]} {
    set line [GetSelection]
    if {$line == {}} {return}
    set listelt [lindex [split $line] 0]
    set handle [$listelt handle]
    set monstfile   [$listelt file]
    if {[$handle type] == "Character"} {
      global CurrentCharacter
      if {$CurrentCharacter(handle) != {}} {
        if {$CurrentCharacter(isdirty)} {
	  set answer [YesNoBox "Modified character data in character frame, lose it?"]
	  if {!$answer} {
	    return
	  }
        }
        $CurrentCharacter(handle) delete
        set CurrentCharacter(handle) {}
        set CurrentCharacter(isdirty) 0
        set CurrentCharacter(filename) {}
        ResetCharacterForm
      }
      set CurrentCharacter(handle) [Character]
      $CurrentCharacter(handle) read $monstfile
      set CurrentCharacter(isdirty) 0   
      set CurrentCharacter(filename) $monstfile
      ResetCharacterForm
      PopFrame CharacterFrame
    } else {
      global CurrentMonster
      if {$CurrentMonster(handle) != {}} {
        if {$CurrentMonster(isdirty)} {
	  set answer [YesNoBox "Modified monster data in monster frame, lose it?"]
	  if {!$answer} {
	    return
	  }
        }
        $CurrentMonster(handle) delete
        set CurrentMonster(handle) {}
        set CurrentMonster(isdirty) 0
        set CurrentMonster(filename) {}
        ResetMonsterForm
      }
      set CurrentMonster(handle) [Monster]
      $CurrentMonster(handle) read $monstfile
      set CurrentMonster(isdirty) 0   
      set CurrentMonster(filename) $monstfile
      ResetMonsterForm
      PopFrame MonsterFrame
    }
  }
}


# Procedure: DescribeBitMap
proc DescribeBitMap { Canvas X Y} {
  set XPos [$Canvas canvasx $X]
  set YPos [$Canvas canvasy $Y]
  set seen {}
  for {set first [$Canvas find closest $XPos $YPos 32]}  {[lsearch -exact $seen $first] < 0}  {set first [$Canvas find closest $XPos $YPos 32 $first]} {
    set bbox [$Canvas bbox $first]
    if {$XPos < [lindex $bbox 0] || $XPos > [lindex $bbox 2] ||  $YPos < [lindex $bbox 1] || $YPos > [lindex $bbox 3]} {
      lappend seen $first
    } else {
      set tags [lindex [$Canvas itemconfigure $first -tags] 4]
      set x [lsearch -exact $tags current]
      if {$x >= 0} {
	set tags [lreplace $tags $x $x]
      }
      AlertBox "[$tags]"
#
      return
    }
  }
}


# Procedure: MoveDrag
proc MoveDrag { Canvas X Y} {
  global Moving
  if {$Moving(Canvas) == $Canvas && $Moving(Index) != {}} {
    set cx [$Canvas canvasx $X]
    set cy [$Canvas canvasy $Y]
    set dx [expr $cx - $Moving(X)]
    set dy [expr $cy - $Moving(Y)]
    set Moving(X) $cx
    set Moving(Y) $cy  
    $Canvas move $Moving(Index) $dx $dy
  }
}


# Procedure: MoveEnd
proc MoveEnd { Canvas} {
  global Moving
  if {$Moving(Canvas) == $Canvas && $Moving(Index) != {}} {
    set xy [$Canvas coords $Moving(Index)]
    set Moving(Index) {}
    if {$Moving(handle) == {}} {return}
    if {[$Moving(handle) type] == "CharacterList"} {
      $Moving(handle) marchx [lindex $xy 0]
      $Moving(handle) marchy [lindex $xy 1]
      global CurrentMasterGame
      if {$CurrentMasterGame(handle) != {}} {
	set CurrentMasterGame(isdirty) 1
      }
    } else {
      $Moving(handle) spacex [lindex $xy 0]
      $Moving(handle) spacey [lindex $xy 1]
      global CurrentMasterDungeon
      if {$CurrentMasterDungeon(handle) != {}} {
	set CurrentMasterDungeon(isdirty) 1
      }
    } 
  }
  
}


# Procedure: MoveStart
proc MoveStart { Canvas X Y check} {
  if {!$check} {return}
  global Moving
  set Moving(X) [$Canvas canvasx $X]
  set Moving(Y) [$Canvas canvasy $Y]
  set Moving(Canvas) $Canvas
  set seen {}
  for {set first [$Canvas find closest $Moving(X) $Moving(Y) 32]}  {[lsearch -exact $seen $first] < 0}  {set first [$Canvas find closest $Moving(X) $Moving(Y) 32 $first]} {
    set bbox [$Canvas bbox $first]
    if {$Moving(X) <= [lindex $bbox 0] ||  $Moving(X) >= [lindex $bbox 2] ||  $Moving(Y) <= [lindex $bbox 1] ||  $Moving(Y) >= [lindex $bbox 3]} {
      lappend seen $first
    } else {
      set Moving(Index) $first
      set tags [lindex [$Canvas itemconfigure $first -tags] 4]
      set x [lsearch -exact $tags current]
      if {$x >= 0} {
	set tags [lreplace $tags $x $x]
      }
      set Moving(handle) "$tags"
      if {$tags == {}} {set Moving(Index) {}}
      return
    }
  }
  set Moving(Index) {}
}


# Procedure: CheckMasterMode
proc CheckMasterMode { mode} {
  global MasterMode
  if {$MasterMode == $mode} {
    return 1
  } else {
    return 0
  }
}


# Procedure: MasterCreateNewTreasure
proc MasterCreateNewTreasure {} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  set name [[SN MasterCreateTrickTreasureName] get]
  set type [[SN MasterCreateTrickTreasureType] get]
  set description [[SN MasterCreateTrickTreasureDescription] get]
  set epval [[SN MasterCreateTrickTreasureEPValue] get]
  if {[catch "expr int($epval)" err]} {
    AlertBox "Bad value for Experience Point value: $epval '$err'"
    [SN MasterCreateTrickTreasureEPValue] delete 0 end
    [SN MasterCreateTrickTreasureEPValue] insert end {0}
    return
  }
  set value [[SN MasterCreateTrickTreasureValue] get]
  if {[catch "expr int($value)" err]} {
    AlertBox "Bad Value: $value '$err'"
    [SN MasterCreateTrickTreasureValue] delete 0 end
    [SN MasterCreateTrickTreasureValue] insert end {0}
    return
  }
  global MasterCreateTrickTreasureIsUnique
  set newTreasure [Treasure "$name" "$type" "$description" $epval $value \
		   $MasterCreateTrickTreasureIsUnique 0]
  set newTreasureList [TreasureList $name {} $newTreasure \
			[$CurrentMasterDungeon(handle) mastertreasurelist] 0 0 \
			$value]
  $CurrentMasterDungeon(handle) mastertreasurelist $newTreasureList
  set CurrentMasterDungeon(isdirty) 1
}


# Procedure: MasterCreateNewTrick
proc MasterCreateNewTrick {} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  set name [[SN MasterCreateTrickTreasureName] get]
  set type [[SN MasterCreateTrickTreasureType] get]
  set description [[SN MasterCreateTrickTreasureDescription] get]
  set value [[SN MasterCreateTrickTreasureValue] get]
  if {[catch "expr int($value)" err]} {
    AlertBox "Bad Value: $value '$err'"
    [SN MasterCreateTrickTreasureValue] delete 0 end
    [SN MasterCreateTrickTreasureValue] insert end {0}
    return
  }
  set newTrick [Trick "$name" "$type" "$description"]
  set newTrickList [TrickList $name {} $newTrick \
			[$CurrentMasterDungeon(handle) mastertricklist] 0 0 \
			$value 0]
  $CurrentMasterDungeon(handle) mastertricklist $newTrickList
  set CurrentMasterDungeon(isdirty) 1
}


# Procedure: MasterCreateTrickTreasureFormReset
proc MasterCreateTrickTreasureFormReset {} {
  [SN MasterCreateTrickTreasureDescription] delete 0 end
  [SN MasterCreateTrickTreasureEPValue] delete 0 end
  [SN MasterCreateTrickTreasureEPValue] insert end {0}
  [SN MasterCreateTrickTreasureName] delete 0 end
  [SN MasterCreateTrickTreasureType] delete 0 end
  [SN MasterCreateTrickTreasureValue] delete 0 end
  [SN MasterCreateTrickTreasureValue] insert end {0}
  global MasterCreateTrickTreasureIsUnique
  set MasterCreateTrickTreasureIsUnique {0}
  focus [SN MasterCreateTrickTreasureName]
}

# Procedure: MasterNewFrame 
proc MasterNewFrame {} {
  global MasterMode
  global CurrentMasterDungeon
  global CurrentMasterGame
  if {$CurrentMasterDungeon(handle) != {} && $MasterMode == "Build"} {
    if {$CurrentMasterGame(handle) != {}} {
      set answer [YesNoBox "Game state active!  Toss before recycling dungeon?"]
      if {!$answer} {
	return
      }
      if {$CurrentMasterGame(isdirty)} {
	set answer [YesNoBox "Game state modified!  Do you *really* want to toss it?"]
	if {!$answer} {
	  return
	}
      }
      TossGame
    }
    if {$CurrentMasterDungeon(isdirty)} {
      set answer [YesNoBox "Modified Dungeon data in master frame, lose it?"]
      if {!$answer} {
	return
      }
    }
    TossDungeon
  } elseif {$CurrentMasterGame(handle) != {} && $MasterMode == "Play"} {
    if {$CurrentMasterGame(isdirty)} {
      set answer [YesNoBox "Modified Game State in master frame, lose it?"]
      if {!$answer} {
	return
      }
    }
    TossGame
  }
  [SN MasterPlayMode] configure -state disabled
  if {$MasterMode == "Build"} {
    set nameLevsXYCom [NewDungeon]
    if {$nameLevsXYCom == {}} {return}
    set name "[lindex $nameLevsXYCom 0]"
    set comments "[lindex $nameLevsXYCom 4]"
    set levels [lindex $nameLevsXYCom 1]
    set xsize  [lindex $nameLevsXYCom 2]
    set ysize  [lindex $nameLevsXYCom 3]
    set CurrentMasterDungeon(handle) [Dungeon "$name" "$comments" $levels $xsize $ysize]
    set CurrentMasterDungeon(isdirty) 1
    set CurrentMasterDungeon(filename) new.dungeon
  } else {
    set CurrentMasterGame(handle) [Game $CurrentMasterDungeon(handle) $CurrentMasterDungeon(filename) "" 0 0 0]
    set CurrentMasterGame(isdirty) 1
    set CurrentMasterGame(filename) new.game
  }
  [SN MasterPlayMode] configure -state normal
  LoadMasterForm
}

# Procedure: GameOrDungeon
proc GameOrDungeon {} {
# .gameOrDungeon
# The above line makes pasting MUCH easier for me.
# It contains the pathname of the cutted widget.
# Tcl version: 7.3 (Tcl/Tk/XF)
# Tk version: 3.6
# XF version: $__lastrelease$
#

  global GameOrDungeonResult
  set GameOrDungeonResult {}

  # build widget .gameOrDungeon
  if {"[info procs XFEdit]" != ""} {
    catch "XFDestroy .gameOrDungeon"
  } {
    catch "destroy .gameOrDungeon"
  }
  toplevel .gameOrDungeon 

  # Window manager configurations
  global tkVersion
  wm positionfrom .gameOrDungeon ""
  wm sizefrom .gameOrDungeon program
  wm maxsize .gameOrDungeon 1000 768
  wm minsize .gameOrDungeon 10 10
  wm title .gameOrDungeon {Game or Dungeon}


  # build widget .gameOrDungeon.buttons
  frame .gameOrDungeon.buttons \
    -borderwidth {2}

  # build widget .gameOrDungeon.buttons.dungeon
  button .gameOrDungeon.buttons.dungeon \
    -font {-Adobe-Helvetica-Bold-R-Normal--*-240-*}\
    -text {Dungeon}\
    -command {
  if {"[info procs XFEdit]" != ""} {
    catch "XFDestroy .gameOrDungeon"
  } {
    catch "destroy .gameOrDungeon"
  }
  global GameOrDungeonResult
  set GameOrDungeonResult {Dungeon}
}

  # build widget .gameOrDungeon.buttons.game
  button .gameOrDungeon.buttons.game \
    -font {-Adobe-Helvetica-Bold-R-Normal--*-240-*}\
    -text {Game} \
    -command {
  if {"[info procs XFEdit]" != ""} {
    catch "XFDestroy .gameOrDungeon"
  } {
    catch "destroy .gameOrDungeon"
  }
  global GameOrDungeonResult
  set GameOrDungeonResult {Game}
}

  # build widget .gameOrDungeon.buttons.help
  button .gameOrDungeon.buttons.help \
    -font {-Adobe-Helvetica-Bold-R-Normal--*-240-*}\
    -text {Help}\
    -command {PopupHelpTopic GameOrDungeon}

  # pack widget .gameOrDungeon.buttons
  pack append .gameOrDungeon.buttons \
    .gameOrDungeon.buttons.game {left frame center expand fill} \
    .gameOrDungeon.buttons.dungeon {left frame center expand fill} \
    .gameOrDungeon.buttons.help {right frame center expand fill}

  # build widget .gameOrDungeon.message33
  message .gameOrDungeon.message33 \
    -aspect {1500}\
    -font {-Adobe-Helvetica-Bold-R-Normal--*-240-*}\
    -padx {5}\
    -pady {2}\
    -text {Load a game or a dungeon?}

  # pack widget .gameOrDungeon
  pack append .gameOrDungeon \
    .gameOrDungeon.message33 {top frame center expand fillx} \
    .gameOrDungeon.buttons {top frame center expand fillx} 
# end of widget tree

  update idletasks
  grab .gameOrDungeon
  tkwait window .gameOrDungeon
  return $GameOrDungeonResult
}

# Procedure: MasterOpenFrame 
proc MasterOpenFrame {} {
  global MasterMode
  global CurrentMasterDungeon
  global CurrentMasterGame
  set which [GameOrDungeon]
  if {$which == "Dungeon"} {
    set MasterMode Build
  } else {
    set MasterMode Play
  }
  if {$CurrentMasterDungeon(handle) != {} && $MasterMode == "Build"} {
    if {$CurrentMasterGame(handle) != {}} {
      set answer [YesNoBox "Game state active!  Toss before recycling dungeon?"]
      if {!$answer} {
	return
      }
      if {$CurrentMasterGame(isdirty)} {
	set answer [YesNoBox "Game state modified!  Do you *really* want to toss it?"]
	if {!$answer} {
	  return
	}
      }
      TossGame
    }
    if {$CurrentMasterDungeon(isdirty)} {
      set answer [YesNoBox "Modified Dungeon data in master frame, lose it?"]
      if {!$answer} {
	return
      }
      TossDungeon
    }
  } elseif {$CurrentMasterGame(handle) != {} && $MasterMode == "Play"} {
    if {$CurrentMasterDungeon(handle) != {}} {
      set answer [YesNoBox "Loading a game replaces the existing dungeon, is this ok?"]
      if {!$answer} {
	return
      }
      if {$CurrentMasterDungeon(isdirty)} {
	set answer [YesNoBox "Dungeon modified!  Do you *really* want to toss it?"]
	if {!$answer} {
	  return
	}
      }
      TossDungeon
    }
    if {$CurrentMasterGame(isdirty)} {
      set answer [YesNoBox "Modified Game State in master frame, lose it?"]
      if {!$answer} {
	return
      }
    }
    TossGame
  }
  [SN MasterPlayMode] configure -state disabled
  if {$MasterMode == "Build"} {
    global fsBox
    set fsBox(pattern) {*.dungeon}
    set newfile [FSBox "Select a dungeon file:"]
    if {$newfile == {}} {return}
    if {![file exists $newfile]} {return}
    set CurrentMasterDungeon(handle) [Dungeon "" "" 0 0 0]
    if {[catch "$CurrentMasterDungeon(handle) read $newfile" error]} {
      $CurrentMasterDungeon(handle) delete
      set CurrentMasterDungeon(handle) {}
      error "$error"
    }
    set CurrentMasterDungeon(isdirty) 0
    set CurrentMasterDungeon(filename) $newfile
  } else {
    global fsBox
    set fsBox(pattern) {*.game}
    set newfile [FSBox "Select a game file:"]
    if {$newfile == {}} {return}
    if {![file exists $newfile]} {return}
    set CurrentMasterGame(handle) [Game "" "" "" 0 0 0]
    if {[catch "$CurrentMasterGame(handle) read $newfile" error]} {
      $CurrentMasterGame(handle) delete
      set CurrentMasterGame(handle) {}
      error "$error"
    }
    set CurrentMasterGame(isdirty) 0
    set CurrentMasterGame(filename) $newfile
    set CurrentMasterDungeon(isdirty) 0
    set CurrentMasterDungeon(handle) [$CurrentMasterGame(handle) dungeonhandle]
    set CurrentMasterDungeon(filename) [$CurrentMasterGame(handle) dungeonfile]
  }
  [SN MasterPlayMode] configure -state normal
  LoadMasterForm
  if {$which == "Game"} {
    MasterChangeMode Play
  } else {
    MasterChangeMode Build
  }
}

# Procedure: MasterSaveFrame 
proc MasterSaveFrame {} {
  global MasterMode
  global CurrentMasterDungeon
  global CurrentMasterGame
  if {$CurrentMasterDungeon(handle) != {} && $CurrentMasterDungeon(isdirty)} {
    $CurrentMasterDungeon(handle) write $CurrentMasterDungeon(filename)
    set CurrentMasterDungeon(isdirty) 0
  }
  if {$CurrentMasterGame(handle) != {} && $CurrentMasterGame(isdirty)} {
    $CurrentMasterGame(handle) write $CurrentMasterGame(filename)
    set CurrentMasterGame(isdirty) 0
  }
}

# Procedure: MasterSaveFrameAs
proc MasterSaveFrameAs {} {
  global MasterMode 
  global CurrentMasterDungeon
  global CurrentMasterGame
  set newdunfile $CurrentMasterDungeon(filename)
  if {$CurrentMasterDungeon(handle) != {}} {
    global fsBox
    set fsBox(pattern) {*.dungeon}
    set newdunfile [FSBox "Save dungeon in file:" $CurrentMasterDungeon(filename)]
    if {$newdunfile == {}} {
      return
    }
  }
  set newgamfile $CurrentMasterGame(filename)
  if {$CurrentMasterGame(handle) != {}} {
    global fsBox
    set fsBox(pattern) {*.game}
    set newgamfile [FSBox "Save game in file:" $CurrentMasterGame(filename)]
    if {$newgamfile == {}} {
      return
    }
  }
  if {$CurrentMasterDungeon(isdirty) || $CurrentMasterDungeon(filename) != $newdunfile} {
    set CurrentMasterDungeon(filename) $newdunfile
    $CurrentMasterDungeon(handle) write $CurrentMasterDungeon(filename)
    set CurrentMasterDungeon(isdirty) 0
  }
  if {$CurrentMasterGame(isdirty) || $CurrentMasterGame(filename) != $newgamfile} {
    set CurrentMasterGame(filename) $newgamfile
    $CurrentMasterGame(handle) write $CurrentMasterGame(filename)
    set CurrentMasterGame(isdirty) 0
  }
}

# Procedure: MasterInstallDoors
proc MasterInstallDoors {} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  set space [$CurrentMasterDungeon(handle) space $CurrentMasterDungeon(level) $CurrentMasterDungeon(x) $CurrentMasterDungeon(y)]
  if {$space == {}} {
    return
  }
  global MasterExitSpace
  foreach e {north northeast east southeast south southwest west northwest
	     up down} {
    $space exit [lindex $e 0] [$MasterExitSpace exit [lindex $e 0]]
  }
  set CurrentMasterDungeon(isdirty) 1
  [SN MasterSpace00] delete all
  DrawSpace [SN MasterSpace00] $space
}

# Procedure: MasterResetDoors
proc MasterResetDoors {} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  set space [$CurrentMasterDungeon(handle) space $CurrentMasterDungeon(level) $CurrentMasterDungeon(x) $CurrentMasterDungeon(y)]
  global MasterExitSpace
  if {$space != {}} {
    foreach e {north northeast east southeast south southwest west northwest
	       up down} {
      $MasterExitSpace exit [lindex $e 0] [$space exit [lindex $e 0]]
    }
  } else {
    foreach e {north northeast east southeast south southwest west northwest
	       up down} {
      $MasterExitSpace exit [lindex $e 0] None
    }
  }
  [SN MasterExitsSubModeSpace] delete all
  MasterDrawSpaceExits [SN MasterExitsSubModeSpace] $MasterExitSpace
  MasterExitSpaceBindBoxes
}


# Procedure: MasterAddSpace
proc MasterAddSpace {} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  if {[$CurrentMasterDungeon(handle) space $CurrentMasterDungeon(level) $CurrentMasterDungeon(x) $CurrentMasterDungeon(y)] != {}} {return}
  NewSpace $CurrentMasterDungeon(handle) $CurrentMasterDungeon(level) $CurrentMasterDungeon(x) $CurrentMasterDungeon(y)
}

# Procedure: MasterRemoveSpace
proc MasterRemoveSpace {} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  set space [$CurrentMasterDungeon(handle) space $CurrentMasterDungeon(level) $CurrentMasterDungeon(x) $CurrentMasterDungeon(y)]
  if {$space == {}} {return}
  $CurrentMasterDungeon(handle) space $CurrentMasterDungeon(level) $CurrentMasterDungeon(x) $CurrentMasterDungeon(y) {}
  DeleteSpace $space
}

# Procedure: MasterUpdateSpace
proc MasterUpdateSpace {} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  set space [$CurrentMasterDungeon(handle) space $CurrentMasterDungeon(level) $CurrentMasterDungeon(x) $CurrentMasterDungeon(y)]
  if {$space == {}} {return}
  $space name "[[SN MasterSquareComments] get 1.0 {1.0 lineend}]"  
  $space spacetype "[[SN MasterSquareComments] get 2.0 {2.0 lineend}]"  
  $space description "[[SN MasterSquareComments] get 4.0 end]"
  set CurrentMasterDungeon(isdirty) 1 
}

# Procedure: MasterDrawSpaceExits
proc MasterDrawSpaceExits {canvas space} {
  global MasterExitPositionList
  foreach e $MasterExitPositionList {
    case [$space exit [lindex $e 0]] in {
      {None} {}
      {Doorway} {
	$canvas create rectangle [lindex $e 1] [lindex $e 2] \
				 [expr [lindex $e 1] + 16] \
				 [expr [lindex $e 2] + 16] \
				 -fill white
      }
      {Door} {
	$canvas create bitmap [lindex $e 1] [lindex $e 2] \
			      -background white -foreground black \
			      -anchor nw -bitmap door
      }
      {DoorSecret} {
	$canvas create bitmap [lindex $e 1] [lindex $e 2] \
			      -background white -foreground black \
			      -anchor nw -bitmap doorsecret
      }
      {DoorLocked} {
	$canvas create bitmap [lindex $e 1] [lindex $e 2] \
			      -background white -foreground black \
			      -anchor nw -bitmap doorlocked
      }
      {DoorOneWay} {
	$canvas create bitmap [lindex $e 1] [lindex $e 2] \
			      -background white -foreground black \
			      -anchor nw -bitmap dooroneway
      }
      {StairsUp} {
	$canvas create bitmap [lindex $e 1] [lindex $e 2] \
			      -background white -foreground black \
			      -anchor nw -bitmap stairsup
      }
      {StairsDown} {
	$canvas create bitmap [lindex $e 1] [lindex $e 2] \
			      -background white -foreground black \
			      -anchor nw -bitmap stairsdown
      }
      {RampUp} {
	$canvas create bitmap [lindex $e 1] [lindex $e 2] \
			      -background white -foreground black \
			      -anchor nw -bitmap rampup
      }
      {RampDown} {
	$canvas create bitmap [lindex $e 1] [lindex $e 2] \
			      -background white -foreground black \
			      -anchor nw -bitmap rampdown
      }
    }
  }
}

# Procedure: MasterExitButtonSet
proc MasterExitButtonSet {exit exittype} {
  global MasterExitSpace
  set space $MasterExitSpace
  set canvas [SN MasterExitsSubModeSpace]
  $space exit $exit $exittype
  $canvas delete all
  MasterDrawSpaceExits $canvas $space
  MasterExitSpaceBindBoxes
}

# Procedure: MasterExitButtonGet
proc MasterExitButtonGet {exit} {
  global MasterExitSpace
  set space $MasterExitSpace
  return [$space exit $exit]
}

# Internal procedures

# Procedure: TossGame
proc TossGame {} {
  global CurrentMasterGame
  set characters [$CurrentMasterGame(handle) players]
  while {$characters != {}} {
    set nextcharacter [$characters nextcharacter]
    set encum [$characters encumbrences]
    while {$encum != {}} {
      set nextencum [$encum nextencumbrence]
      $encum delete
      set encum $nextencum
    }
    $characters delete
    set characters $nextcharacter
  }
  puts stderr "$CurrentMasterGame(handle) delete"
  $CurrentMasterGame(handle) delete
  set CurrentMasterGame(handle) {}
  set CurrentMasterGame(isdirty) 0
  set CurrentMasterGame(filename) {}
}

# Procedure: TossDungeon
proc TossDungeon {} {
  global CurrentMasterDungeon
  set levels [$CurrentMasterDungeon(handle) levels]
  set xsize [$CurrentMasterDungeon(handle) xsize]
  set ysize [$CurrentMasterDungeon(handle) ysize]
  for {set ilev 0} {$ilev < $levels} {incr ilev} {
    for {set ix 0} {$ix < $xsize} {incr ix} {
      for {set iy 0} {$iy < $ysize} {incr iy} {
	set aspace [$CurrentMasterDungeon(handle) space $ilev $ix $iy]
	if {$aspace != {}} {
	  puts stderr "Tossing $aspace at $ilev $ix $iy"
	  set monsters [$aspace monsters]
	  set dressings [$aspace dressings]
	  set treasures [$aspace treasures]
	  set tricks [$aspace tricks]
	  $aspace delete
	  $CurrentMasterDungeon(handle) space $ilev $ix $iy {}
	  while {$monsters != {}} {
	    set nextmonster [$monsters nextmonster]
	    $monsters delete
	    set monsters $nextmonster
	  }
	  while {$dressings != {}} {
	    set nextdressing [$dressings nextdressing]
	    $dressings delete
	    set dressings $nextdressing
	  }
	  while {$treasures != {}} {
	    set nexttreasure [$treasures nexttreasure]
	    $treasures delete
	    set treasures $nexttreasure
	  }
	  while {$tricks != {}} {
	    set nexttrick [$tricks nexttrick]
	    $tricks delete
	    set tricks $nexttrick
	  }
	}
      }
    }
  }
  set npcs [$CurrentMasterDungeon(handle) npclist]
  while {$npcs != {}} {
    set nextnpc [$npcs nextcharacter]
    set character [$npcs handle]
    global CurrentCharacter
    if {$character != $CurrentCharacter(handle)} {$character delete}
    set encum [$npcs encumbrences]
    while {$encum != {}} {
      set nextencum [$encum nextencumbrence]
      $encum delete
      set encum $nextencum
    }
    $npcs delete
    set npcs $nextnpc
  }
  set monsters [$CurrentMasterDungeon(handle) mastermonsterlist]
  while {$monsters != {}} {
    set nextmonster [$monsters nextmonster]
    set monster [$monsters handle]
    global CurrentMonster
    if {$monster != $CurrentMonster(handle)} {$monster delete}
    $monsters delete
    set monsters $nextmonster
  }
  set treasures [$CurrentMasterDungeon(handle) mastertreasurelist]
  while {$treasures != {}} {
    set nexttreasure [$treasures nexttreasure]
    set treasure [$treasures handle]
    $treasure delete
    $treasures delete
    set treasures $nexttreasure
  }
  set tricks [$CurrentMasterDungeon(handle) mastertricklist]
  while {$tricks != {}} {
    set nexttrick [$tricks nexttrick]
    set trick [$tricks handle]
    $trick delete
    $tricks delete
    set tricks $nexttrick
  }
  $CurrentMasterDungeon(handle) delete
  set CurrentMasterDungeon(handle) {}
  set CurrentMasterDungeon(isdirty) 0 
  set CurrentMasterDungeon(filename) {}
}

# Procedure: Is3Numbers
proc Is3Numbers {n3list} {
  if {[llength $n3list] != 3} {
    return 0
  }
  for {set i 0} {$i < 3} {incr i} {
    if {[catch "expr int([lindex $n3list $i])" err]} {
      return 0
    }
    if {[lindex $n3list $i] <= 0} {
      return 0
    }
  }
  return 1
}

# Procedure: LoadMasterForm
proc LoadMasterForm {} {
  global MasterMode
  global CurrentMasterDungeon
  global CurrentMasterGame
  CLDelete [SN MasterCharacterList] 0 [expr [CLSize [SN MasterCharacterList]] - 1]
  set canvas [SN MasterMarchCanvas]
  $canvas delete all
  set CurrentMasterDungeon(level) 0
  set CurrentMasterDungeon(x) 0
  set CurrentMasterDungeon(y) 0
  [SN MasterLocationLevel] delete 0 end
  [SN MasterLocationLevel] insert end {0}
  [SN MasterLocationX] delete 0 end
  [SN MasterLocationX] insert end {0}
  [SN MasterLocationY] delete 0 end
  [SN MasterLocationY] insert end {0}
  if {$CurrentMasterGame(handle) != {}} {
    set characters [$CurrentMasterGame(handle) players]
    while {$characters != {}} {
      set nextcharacter [$characters nextcharacter]
      set chbitmap [$characters bitmap]
      set chhand   [$characters handle]
      set chX      [$characters marchx]
      set chY      [$characters marchy]
      set chName   [$chhand name]
      set chPlayer [$chhand player]
      set chFile   [$characters file]
      set line "$characters - $chhand - $chName ($chPlayer])"
      CLInsert [SN MasterCharacterList] end $chbitmap "$line"
      $canvas create bitmap $chX $chY -bitmap $chbitmap -anchor nw -tag $characters
      $canvas bind $characters <Button-2> "MasterIconSelect [SN MasterCharacterList] \"$line\""
      set characters $nextcharacter
    }
    set CurrentMasterDungeon(level) [$CurrentMasterGame(handle) curlevel]
    set CurrentMasterDungeon(x) [$CurrentMasterGame(handle) curx]
    set CurrentMasterDungeon(y) [$CurrentMasterGame(handle) cury]
    [SN MasterLocationLevel] delete 0 end
    [SN MasterLocationLevel] insert end $CurrentMasterDungeon(level)
    [SN MasterLocationX] delete 0 end
    [SN MasterLocationX] insert end $CurrentMasterDungeon(x)
    [SN MasterLocationY] delete 0 end
    [SN MasterLocationY] insert end $CurrentMasterDungeon(y)
  }
  UpdateSpaceForm
}

# Procedure: UpdateSpaceForm
proc UpdateSpaceForm {} {
  global CurrentMasterDungeon
  # flush monster, other, trick and treasure lists
  CLDelete [SN MasterMonstersList] 0 [expr [CLSize [SN MasterMonstersList]] - 1]
  CLDelete [SN MasterOtherList] 0 [expr [CLSize [SN MasterOtherList]] - 1]
  CLDelete [SN MasterTreasureList] 0 [expr [CLSize [SN MasterTreasureList]] - 1]
  CLDelete [SN MasterTrickList] 0 [expr [CLSize [SN MasterTrickList]] - 1]
  [SN MasterSquareComments] delete 1.0 end
  if {$CurrentMasterDungeon(handle) != {}} {
    for {set yy -1} {$yy < 2} {incr yy} {
      set cy [expr $yy + $CurrentMasterDungeon(y)]
      if {$cy < 0 || $cy >= [$CurrentMasterDungeon(handle) ysize]} {
	for {set xx  -1} {$xx < 2} {incr xx} {
	  [SN MasterSpace$xx$yy] delete all
	  [SN MasterSpace$xx$yy] configure -background {#ffe4c4}
	}
	continue
      }
      for {set xx  -1} {$xx < 2} {incr xx} {
	set cx [expr $xx + $CurrentMasterDungeon(x)]
	[SN MasterSpace$xx$yy] delete all
	if {$cx < 0 || $cx >=  [$CurrentMasterDungeon(handle) xsize]} {
	  [SN MasterSpace$xx$yy] configure -background {#ffe4c4}
	  continue
	}
	[SN MasterSpace$xx$yy] configure -background white
	set space [$CurrentMasterDungeon(handle) space $CurrentMasterDungeon(level) $cx $cy]
	if {$space == {}} {continue}
	DrawSpace [SN MasterSpace$xx$yy] $space
        if {$xx == 0 && $yy == 0} {
	  # fill monster, other, trick and treasure lists from $space
	  set monsters [$space monsters]
	  set dressings [$space dressings]
	  set treasures [$space treasures]
	  set tricks [$space tricks]
	  while {$monsters != {}} {
	    set nextmonster [$monsters nextmonster]
	    set bitmap [$monsters bitmap]
	    set handle [$monsters handle]
	    set line "$monsters ($handle) - [$handle name]"
	    CLInsert [SN MasterMonstersList] end $bitmap $line
	    [SN MasterSpace00] bind $monsters <Button-2> "MasterIconSelect [SN MasterMonstersList] \"$line\""
	    set monsters $nextmonster
	  }
	  while {$dressings != {}} {
	    set nextdressing [$dressings nextdressing]
	    set bitmap [$dressings bitmap]
	    set line "$dressings - [$dressings name] - [$dressings description]"
	    CLInsert [SN MasterOtherList] end $bitmap $line
	    [SN MasterSpace00] bind $dressings <Button-2> "MasterIconSelect [SN MasterOtherList] \"$line\""
	    set dressings $nextdressing
	  }
	  while {$treasures != {}} {
	    set nexttreasure [$treasures nexttreasure]
	    set bitmap [$treasures bitmap]
	    set handle [$treasures handle]
	    set line "$treasures - $handle - [$handle name]"
	    CLInsert [SN MasterTreasureList] end $bitmap $line
	    [SN MasterSpace00] bind $treasures <Button-2> "MasterIconSelect [SN MasterTreasureList] \"$line\""
	    set treasures $nexttreasure
	  }
	  while {$tricks != {}} {
	    set nexttrick [$tricks nexttrick]
	    set bitmap [$tricks bitmap]
	    set handle [$tricks handle]
	    set line "$tricks - $handle - [$handle name]"
	    CLInsert [SN MasterTrickList] end $bitmap $line
	    [SN MasterSpace00] bind $tricks <Button-2> "MasterIconSelect [SN MasterTrickList] \"$line\""
	    set tricks $nexttrick
	  }
	  global MasterExitSpace
	  foreach e {north northeast east southeast south southwest west northwest
		     up down} {
	    $MasterExitSpace exit [lindex $e 0] [$space exit [lindex $e 0]]
	  }
	  [SN MasterExitsSubModeSpace] delete all
	  MasterDrawSpaceExits [SN MasterExitsSubModeSpace] $MasterExitSpace
	  MasterExitSpaceBindBoxes
	  [SN MasterSquareComments] insert end "[$space name]\n[$space spacetype]\n\n"
	  [SN MasterSquareComments] insert end "[$space description]"
	}
      }
    }
  }
  global CurrentMasterGame
  global MasterMode
  if {$MasterMode == "Play" && $CurrentMasterGame(handle) != {}} {
    $CurrentMasterGame(handle) curlevel $CurrentMasterDungeon(level)
    $CurrentMasterGame(handle) curx $CurrentMasterDungeon(x)
    $CurrentMasterGame(handle) cury $CurrentMasterDungeon(y)
    set CurrentMasterGame(isdirty) 1
  }
}

# Procedure: DrawSpace
proc DrawSpace {canvas space} {
  set bcolor "[$space backgroundcolor]"
  if {$bcolor == ""} {set bcolor white}
  $canvas configure -background $bcolor
  set monsters [$space monsters]
  set dressings [$space dressings]
  set treasures [$space treasures]
  set tricks [$space tricks]
  while {$monsters != {}} {
    set nextmonster [$monsters nextmonster]
    set bitmap [$monsters bitmap]
    set x [$monsters spacex]
    set y [$monsters spacey]
    $canvas create bitmap $x $y -anchor nw -bitmap $bitmap -tags $monsters
    set monsters $nextmonster
  }
  while {$dressings != {}} {
    set nextdressing [$dressings nextdressing]
    set bitmap [$dressings bitmap]
    set x [$dressings spacex]
    set y [$dressings spacey]
    $canvas create bitmap $x $y -anchor nw -bitmap $bitmap -tags $dressings
    set dressings $nextdressing
  }
  while {$treasures != {}} {
    set nexttreasure [$treasures nexttreasure]
    set bitmap [$treasures bitmap]
    set x [$treasures spacex]
    set y [$treasures spacey]
    $canvas create bitmap $x $y -anchor nw -bitmap $bitmap -tags $treasures
    set treasures $nexttreasure
  }
  while {$tricks != {}} {
    set nexttrick [$tricks nexttrick]
    set bitmap [$tricks bitmap]
    set x [$tricks spacex]
    set y [$tricks spacey]
    $canvas create bitmap $x $y -anchor nw -bitmap $bitmap -tags $tricks
    set tricks $nexttrick
  }
  MasterDrawSpaceExits $canvas $space
}

# Procedure: GetMonsterOrNPC
proc GetMonsterOrNPC {} {

  global GetMonsterOrNPCResult
  set GetMonsterOrNPCResult {}

  global CurrentMasterDungeon

  if {$CurrentMasterDungeon(handle) == {}} {
    return {}
  }

  # build widget .selectMonsterNPC
  if {"[info procs XFEdit]" != ""} {
    catch "XFDestroy .selectMonsterNPC"
  } {
    catch "destroy .selectMonsterNPC"
  }
  toplevel .selectMonsterNPC 

  # Window manager configurations
  global tkVersion
  wm positionfrom .selectMonsterNPC ""
  wm sizefrom .selectMonsterNPC program
  wm maxsize .selectMonsterNPC 1000 768
  wm minsize .selectMonsterNPC 10 10
  wm title .selectMonsterNPC {Select Monster or NPC}


  # build widget .selectMonsterNPC.buttons
  frame .selectMonsterNPC.buttons \
    -borderwidth {2}

  # build widget .selectMonsterNPC.buttons.cancel
  button .selectMonsterNPC.buttons.cancel \
    -text {Cancel}\
    -command {SelectMonsterNPCSelectCancel .selectMonsterNPC}

  # build widget .selectMonsterNPC.buttons.ok
  button .selectMonsterNPC.buttons.ok \
    -text {OK}\
    -command {SelectMonsterNPCSelectOk .selectMonsterNPC}

  # build widget .selectMonsterNPC.buttons.help
  button .selectMonsterNPC.buttons.help \
    -text {Help}\
    -command {PopupHelpTopic SelectMonsterNPC}

  # pack widget .selectMonsterNPC.buttons
  pack append .selectMonsterNPC.buttons \
    .selectMonsterNPC.buttons.ok {left frame center expand} \
    .selectMonsterNPC.buttons.cancel {left frame center expand} \
    .selectMonsterNPC.buttons.help {right frame center expand}

  # build widget .selectMonsterNPC.lists
  frame .selectMonsterNPC.lists \
    -borderwidth {2}

  # build widget .selectMonsterNPC.lists.monsterList
  frame .selectMonsterNPC.lists.monsterList 

  # build widget .selectMonsterNPC.lists.monsterList.scrollbar2
  scrollbar .selectMonsterNPC.lists.monsterList.scrollbar2 \
    -command {.selectMonsterNPC.lists.monsterList.list yview}\
    -relief {raised}

  # build widget .selectMonsterNPC.lists.monsterList.scrollbar3
  scrollbar .selectMonsterNPC.lists.monsterList.scrollbar3 \
    -command {.selectMonsterNPC.lists.monsterList.list xview}\
    -orient {horizontal}\
    -relief {raised}

  # build widget .selectMonsterNPC.lists.monsterList.list
  listbox .selectMonsterNPC.lists.monsterList.list \
    -geometry {31x10}\
    -relief {raised}\
    -xscrollcommand {.selectMonsterNPC.lists.monsterList.scrollbar3 set}\
    -yscrollcommand {.selectMonsterNPC.lists.monsterList.scrollbar2 set}
  # bindings
  bind .selectMonsterNPC.lists.monsterList.list <Double-Button-1> {SelectMonsterNPCSelectDouble .selectMonsterNPC %W %y}
  bind .selectMonsterNPC.lists.monsterList.list <ButtonPress-1> {SelectMonsterNPCSelect .selectMonsterNPC %W %y}
  bind .selectMonsterNPC.lists.monsterList.list <Button1-Motion> {SelectMonsterNPCSelect .selectMonsterNPC %W %y}
  bind .selectMonsterNPC.lists.monsterList.list <Shift-Button1-Motion> {SelectMonsterNPCSelect .selectMonsterNPC %W %y}
  bind .selectMonsterNPC.lists.monsterList.list <Shift-ButtonPress-1> {SelectMonsterNPCSelect .selectMonsterNPC %W %y}

  # pack widget .selectMonsterNPC.lists.monsterList
  pack append .selectMonsterNPC.lists.monsterList \
    .selectMonsterNPC.lists.monsterList.scrollbar2 {right frame center filly} \
    .selectMonsterNPC.lists.monsterList.list {top frame center expand fill} \
    .selectMonsterNPC.lists.monsterList.scrollbar3 {bottom frame center fillx} 

  # build widget .selectMonsterNPC.lists.npcList
  frame .selectMonsterNPC.lists.npcList 

  # build widget .selectMonsterNPC.lists.npcList.scrollbar2
  scrollbar .selectMonsterNPC.lists.npcList.scrollbar2 \
    -command {.selectMonsterNPC.lists.npcList.list yview}\
    -relief {raised}

  # build widget .selectMonsterNPC.lists.npcList.scrollbar3
  scrollbar .selectMonsterNPC.lists.npcList.scrollbar3 \
    -command {.selectMonsterNPC.lists.npcList.list xview}\
    -orient {horizontal}\
    -relief {raised}

  # build widget .selectMonsterNPC.lists.npcList.list
  listbox .selectMonsterNPC.lists.npcList.list \
    -geometry {31x10}\
    -relief {raised}\
    -xscrollcommand {.selectMonsterNPC.lists.npcList.scrollbar3 set}\
    -yscrollcommand {.selectMonsterNPC.lists.npcList.scrollbar2 set}
  # bindings
  bind .selectMonsterNPC.lists.npcList.list <Double-Button-1> {SelectMonsterNPCSelectDouble .selectMonsterNPC %W %y}
  bind .selectMonsterNPC.lists.npcList.list <ButtonPress-1> {SelectMonsterNPCSelect .selectMonsterNPC %W %y}
  bind .selectMonsterNPC.lists.npcList.list <Button1-Motion> {SelectMonsterNPCSelect .selectMonsterNPC %W %y}
  bind .selectMonsterNPC.lists.npcList.list <Shift-Button1-Motion> {SelectMonsterNPCSelect .selectMonsterNPC %W %y}
  bind .selectMonsterNPC.lists.npcList.list <Shift-ButtonPress-1> {SelectMonsterNPCSelect .selectMonsterNPC %W %y}

  # pack widget .selectMonsterNPC.lists.npcList
  pack append .selectMonsterNPC.lists.npcList \
    .selectMonsterNPC.lists.npcList.scrollbar2 {right frame center filly} \
    .selectMonsterNPC.lists.npcList.list {top frame center expand fill} \
    .selectMonsterNPC.lists.npcList.scrollbar3 {bottom frame center fillx} 

  # pack widget .selectMonsterNPC.lists
  pack append .selectMonsterNPC.lists \
    .selectMonsterNPC.lists.monsterList {left frame center fill} \
    .selectMonsterNPC.lists.npcList {left frame center fill} 

  # build widget .selectMonsterNPC.selected
  frame .selectMonsterNPC.selected \
    -borderwidth {2}

  # build widget .selectMonsterNPC.selected.label5
  label .selectMonsterNPC.selected.label5 \
    -text {Selected monster or NPC:}

  # build widget .selectMonsterNPC.selected.selection
  entry .selectMonsterNPC.selected.selection \
    -relief {sunken}
  # bindings
  bind .selectMonsterNPC.selected.selection <Key-Return> {.selectMonsterNPC.buttons.ok invoke}

  # pack widget .selectMonsterNPC.selected
  pack append .selectMonsterNPC.selected \
    .selectMonsterNPC.selected.label5 {left frame center} \
    .selectMonsterNPC.selected.selection {left frame center expand fillx} 

  # pack widget .selectMonsterNPC
  pack append .selectMonsterNPC \
    .selectMonsterNPC.lists {top frame center fillx} \
    .selectMonsterNPC.selected {top frame center fillx} \
    .selectMonsterNPC.buttons {top frame center fillx} 

  .selectMonsterNPC.selected.selection insert end {}

  set npcs [$CurrentMasterDungeon(handle) npclist]
  while {$npcs != {}} {
    set nextnpc [$npcs nextcharacter]   
    set character [$npcs handle]
    .selectMonsterNPC.lists.npcList.list insert end "$npcs - [$character name]"
    set npcs $nextnpc
  }
  set monsters [$CurrentMasterDungeon(handle) mastermonsterlist]
  while {$monsters != {}} {
    set nextmonster [$monsters nextmonster]
    set monster [$monsters handle]
    .selectMonsterNPC.lists.monsterList.list insert end "$monsters - [$monster name]"
    set monsters $nextmonster
  }

  focus .selectMonsterNPC.selected.selection

# end of widget tree

  update idletasks
  grab .selectMonsterNPC
  tkwait window .selectMonsterNPC

  return $GetMonsterOrNPCResult
}

# Procedure: SelectMonsterNPCSelectCancel
proc SelectMonsterNPCSelectCancel {toplevel} {
  if {"[info commands XFDestroy]" != ""} {
    catch "XFDestroy $toplevel"
  } else {
    catch "destroy $toplevel"
  }
  global GetMonsterOrNPCResult
  set GetMonsterOrNPCResult {}
}

# Procedure: SelectMonsterNPCSelectOk
proc SelectMonsterNPCSelectOk {toplevel} {
  global GetMonsterOrNPCResult
  set GetMonsterOrNPCResult "[lindex [$toplevel.selected.selection get] 0]"
  if {"[info commands XFDestroy]" != ""} {
    catch "XFDestroy $toplevel"
  } else {
    catch "destroy $toplevel"
  }
}

# Procedure: SelectMonsterNPCSelectDouble
proc SelectMonsterNPCSelectDouble {top W y} {
  SelectMonsterNPCSelect $top $W $y
  SelectMonsterNPCSelectOk $top
}

# Procedure: SelectMonsterNPCSelect
proc SelectMonsterNPCSelect {top W y} {
  SelectMonsterNPCSelectOne $W $y
  set nearest [$W nearest $y]
  set selection "[$W get $nearest]"
  $top.selected.selection delete 0 end
  $top.selected.selection insert end "$selection"
}

# Procedure: SelectMonsterNPCSelectOne
proc SelectMonsterNPCSelectOne {W y} {
  set nearest [$W nearest $y]
  if {$nearest >= 0} {
    $W select from $nearest
    $W select to $nearest
  }
}

# Procedure: NewSpace
proc NewSpace {dunhandle l x y} {

  global newSpace
  set newSpace(name) {}
  set newSpace(type) {}
  set newSpace(color) {}
  set newSpace(description) {}
  set newSpace(button) {}

  # build widget .newSpace
  if {"[info procs XFEdit]" != ""} {
    catch "XFDestroy .newSpace"
  } {
    catch "destroy .newSpace"
  }
  toplevel .newSpace 

  # Window manager configurations
  global tkVersion
  wm positionfrom .newSpace ""
  wm sizefrom .newSpace program
  wm maxsize .newSpace 1000 768
  wm minsize .newSpace 10 10
  wm title .newSpace {Describe New Space}


  # build widget .newSpace.backgroundColor
  frame .newSpace.backgroundColor \
    -borderwidth {2}

  # build widget .newSpace.backgroundColor.button13
  button .newSpace.backgroundColor.button13 \
    -command {set newcolor [ColorBox]
.newSpace.backgroundColor.color delete 0 end
.newSpace.backgroundColor.color insert end $newcolor}\
    -text {Browse}

  # build widget .newSpace.backgroundColor.color
  entry .newSpace.backgroundColor.color \
    -relief {sunken}
  # bindings
  bind .newSpace.backgroundColor.color <Key-Return> {focus .newSpace.description.frame.text2}

  # build widget .newSpace.backgroundColor.label11
  label .newSpace.backgroundColor.label11 \
    -text {Background Color:}

  # pack widget .newSpace.backgroundColor
  pack append .newSpace.backgroundColor \
    .newSpace.backgroundColor.label11 {left frame center} \
    .newSpace.backgroundColor.color {left frame center expand fillx} \
    .newSpace.backgroundColor.button13 {right frame center} 

  # build widget .newSpace.buttons
  frame .newSpace.buttons \
    -borderwidth {2}

  # build widget .newSpace.buttons.cancel
  button .newSpace.buttons.cancel \
    -command {global newSpace
set newSpace(button) {cancel}
if {"[info commands XFDestroy]" != ""} {
  catch "XFDestroy .newSpace"
} else {
  catch "destroy .newSpace"
}
}\
    -text {Cancel}

  # build widget .newSpace.buttons.ok
  button .newSpace.buttons.ok \
    -command {global newSpace
set newSpace(name) "[.newSpace.name.name get]"
set newSpace(type) "[.newSpace.type.type get]"
set newSpace(color) "[.newSpace.backgroundColor.color get]"
set newSpace(description) "[.newSpace.description.frame.text2 get 1.0 end]"
set newSpace(button) {ok}
if {"[info commands XFDestroy]" != ""} {
  catch "XFDestroy .newSpace"
} else {
  catch "destroy .newSpace"
}
}\
    -text {OK}

  # build widget .newSpace.buttons.help
  button .newSpace.buttons.help \
    -text {Help}\
    -command {PopupHelpTopic NewSpace}

  # pack widget .newSpace.buttons
  pack append .newSpace.buttons \
    .newSpace.buttons.ok {left frame center expand} \
    .newSpace.buttons.cancel {left frame center expand} \
    .newSpace.buttons.help {right frame center expand}

  # build widget .newSpace.description
  frame .newSpace.description \
    -borderwidth {2}

  # build widget .newSpace.description.frame
  frame .newSpace.description.frame \
    -relief {raised}

  # build widget .newSpace.description.frame.scrollbar1
  scrollbar .newSpace.description.frame.scrollbar1 \
    -command {.newSpace.description.frame.text2 yview}\
    -relief {raised}

  # build widget .newSpace.description.frame.text2
  text .newSpace.description.frame.text2 \
    -borderwidth {2}\
    -height {9}\
    -relief {sunken}\
    -width {56}\
    -wrap {none}\
    -yscrollcommand {.newSpace.description.frame.scrollbar1 set}

  # pack widget .newSpace.description.frame
  pack append .newSpace.description.frame \
    .newSpace.description.frame.scrollbar1 {right frame center filly} \
    .newSpace.description.frame.text2 {top frame center expand fill} 

  # build widget .newSpace.description.label10
  label .newSpace.description.label10 \
    -text {Description:}

  # pack widget .newSpace.description
  pack append .newSpace.description \
    .newSpace.description.label10 {top frame w} \
    .newSpace.description.frame {top frame center fill} 

  # build widget .newSpace.name
  frame .newSpace.name \
    -borderwidth {2}

  # build widget .newSpace.name.label6
  label .newSpace.name.label6 \
    -text {Name:}

  # build widget .newSpace.name.name
  entry .newSpace.name.name \
    -relief {sunken}
  # bindings
  bind .newSpace.name.name <Key-Return> {focus .newSpace.type.type}

  # pack widget .newSpace.name
  pack append .newSpace.name \
    .newSpace.name.label6 {left frame center} \
    .newSpace.name.name {left frame center expand fillx} 

  # build widget .newSpace.type
  frame .newSpace.type \
    -borderwidth {2}

  # build widget .newSpace.type.label8
  label .newSpace.type.label8 \
    -text {Type:}

  # build widget .newSpace.type.type
  entry .newSpace.type.type \
    -relief {sunken}
  # bindings
  bind .newSpace.type.type <Key-Return> {focus .newSpace.backgroundColor.color}

  # pack widget .newSpace.type
  pack append .newSpace.type \
    .newSpace.type.label8 {left frame center} \
    .newSpace.type.type {left frame center expand fillx} 

  # pack widget .newSpace
  pack append .newSpace \
    .newSpace.name {top frame center fillx} \
    .newSpace.type {top frame center fillx} \
    .newSpace.backgroundColor {top frame center fillx} \
    .newSpace.description {top frame center fillx} \
    .newSpace.buttons {top frame center fillx} 

  .newSpace.backgroundColor.color insert end {}
  .newSpace.description.frame.text2 insert end {}
  .newSpace.name.name insert end {}
  .newSpace.type.type insert end {}


# end of widget tree
  
  update idletasks
  grab .newSpace
  tkwait window .newSpace

  if {$newSpace(button) == {cancel}} {
    return
  }
  set space [Space "$newSpace(name)" "$newSpace(type)" "$newSpace(description)" "$newSpace(color)" {} {} {} {} {}]
  $dunhandle space $l $x $y $space
  DrawSpace [SN MasterSpace00] $space
  CLDelete [SN MasterMonstersList] 0 [expr [CLSize [SN MasterMonstersList]] - 1]
  CLDelete [SN MasterOtherList] 0 [expr [CLSize [SN MasterOtherList]] - 1]
  CLDelete [SN MasterTreasureList] 0 [expr [CLSize [SN MasterTreasureList]] - 1]
  CLDelete [SN MasterTrickList] 0 [expr [CLSize [SN MasterTrickList]] - 1]
  [SN MasterSquareComments] delete 1.0 end
  global MasterExitSpace
  foreach e {north northeast east southeast south southwest west northwest
	     up down} {
    $space exit [lindex $e 0] [$MasterExitSpace exit [lindex $e 0]]
  }
  [SN MasterSquareComments] insert end "[$space name]\n[$space spacetype]\n\n"
  [SN MasterSquareComments] insert end "[$space description]"
  return $space
}

# Procedure: NewDungeon
proc NewDungeon {} {
  global newDungeon
  set newDungeon(name) {}
  set newDungeon(comments) {}
  set newDungeon(levels) {0}
  set newDungeon(xsize) {0}
  set newDungeon(ysize) {0}
  set newDungeon(button) {}

  # build widget .newDungeon
  if {"[info procs XFEdit]" != ""} {
    catch "XFDestroy .newDungeon"
  } {
    catch "destroy .newDungeon"
  }
  toplevel .newDungeon 

  # Window manager configurations
  global tkVersion
  wm positionfrom .newDungeon ""
  wm sizefrom .newDungeon program
  wm maxsize .newDungeon 1000 768
  wm minsize .newDungeon 10 10
  wm title .newDungeon {Describe New Dungeon}


  # build widget .newDungeon.buttons
  frame .newDungeon.buttons \
    -borderwidth {2}

  # build widget .newDungeon.buttons.cancel
  button .newDungeon.buttons.cancel \
    -command {global newDungeon
set newDungeon(button) {cancel}
if {"[info commands XFDestroy]" != ""} {
  catch "XFDestroy .newDungeon"
} else {
  catch "destroy .newDungeon"
}
}\
    -text {Cancel}

  # build widget .newDungeon.buttons.ok
  button .newDungeon.buttons.ok \
    -command {NewDungeonOk}\
    -text {OK}

  # build widget .newDungeon.buttons.help
  button .newDungeon.buttons.help \
    -command {PopupHelpTopic NewDungeon}\
    -text {Help}

  # pack widget .newDungeon.buttons
  pack append .newDungeon.buttons \
    .newDungeon.buttons.ok {left frame center expand} \
    .newDungeon.buttons.cancel {left frame center expand} \
    .newDungeon.buttons.help {right frame center expand}

  # build widget .newDungeon.comments
  frame .newDungeon.comments \
    -borderwidth {2}

  # build widget .newDungeon.comments.frame
  frame .newDungeon.comments.frame \
    -relief {raised}

  # build widget .newDungeon.comments.frame.scrollbar1
  scrollbar .newDungeon.comments.frame.scrollbar1 \
    -command {.newDungeon.comments.frame.text2 yview}\
    -relief {raised}

  # build widget .newDungeon.comments.frame.text2
  text .newDungeon.comments.frame.text2 \
    -borderwidth {2}\
    -height {9}\
    -relief {sunken}\
    -width {56}\
    -wrap {none}\
    -yscrollcommand {.newDungeon.comments.frame.scrollbar1 set}

  # pack widget .newDungeon.comments.frame
  pack append .newDungeon.comments.frame \
    .newDungeon.comments.frame.scrollbar1 {right frame center filly} \
    .newDungeon.comments.frame.text2 {top frame center expand fill} 

  # build widget .newDungeon.comments.label10
  label .newDungeon.comments.label10 \
    -text {Comments:}

  # pack widget .newDungeon.comments
  pack append .newDungeon.comments \
    .newDungeon.comments.label10 {top frame w} \
    .newDungeon.comments.frame {top frame center fill} 

  # build widget .newDungeon.name
  frame .newDungeon.name \
    -borderwidth {2}

  # build widget .newDungeon.name.label6
  label .newDungeon.name.label6 \
    -text {Name:}

  # build widget .newDungeon.name.name
  entry .newDungeon.name.name \
    -relief {sunken}
  # bindings
  bind .newDungeon.name.name <Key-Return> {focus .newDungeon.size.levels}

  # pack widget .newDungeon.name
  pack append .newDungeon.name \
    .newDungeon.name.label6 {left frame center} \
    .newDungeon.name.name {left frame center expand fillx} 

  # build widget .newDungeon.size
  frame .newDungeon.size \
    -borderwidth {2}

  # build widget .newDungeon.size.label8
  label .newDungeon.size.label8 \
    -text {Levels:}

  # build widget .newDungeon.size.levels
  entry .newDungeon.size.levels \
    -relief {sunken}
  # bindings
  bind .newDungeon.size.levels <Key-Return> {focus .newDungeon.size.xsize}

  # build widget .newDungeon.size.label9
  label .newDungeon.size.label9 \
    -text {XSize:}

  # build widget .newDungeon.size.xsize
  entry .newDungeon.size.xsize \
    -relief {sunken}
  # bindings
  bind .newDungeon.size.xsize <Key-Return> {focus .newDungeon.size.ysize}

  # build widget .newDungeon.size.label10
  label .newDungeon.size.label10 \
    -text {YSize:}

  # build widget .newDungeon.size.ysize
  entry .newDungeon.size.ysize \
    -relief {sunken}
  # bindings
  bind .newDungeon.size.ysize <Key-Return> {focus .newDungeon.comments.frame.text2}

  # pack widget .newDungeon.size
  pack append .newDungeon.size \
    .newDungeon.size.label8 {left frame center} \
    .newDungeon.size.levels {left frame center expand fillx} \
    .newDungeon.size.label9 {left frame center} \
    .newDungeon.size.xsize {left frame center expand fillx} \
    .newDungeon.size.label10 {left frame center} \
    .newDungeon.size.ysize {left frame center expand fillx} 

  # pack widget .newDungeon
  pack append .newDungeon \
    .newDungeon.name {top frame center fillx} \
    .newDungeon.size {top frame center fillx} \
    .newDungeon.comments {top frame center fillx} \
    .newDungeon.buttons {top frame center fillx} 

  .newDungeon.comments.frame.text2 insert end {}
  .newDungeon.name.name insert end {}
  .newDungeon.size.levels insert end {1}
  .newDungeon.size.xsize insert end {1}
  .newDungeon.size.ysize insert end {1}


# end of widget tree

  focus .newDungeon.name.name
  update idletasks
  grab .newDungeon
  tkwait window .newDungeon

  if {$newDungeon(button) == {ok}} {
    return [list "$newDungeon(name)" $newDungeon(levels) $newDungeon(xsize) $newDungeon(ysize) "$newDungeon(comments)"]
  } else {
    return {}
  }

}

# Procedure: NewDungeonOk
proc NewDungeonOk {} {
  global newDungeon
  set newDungeon(name) "[.newDungeon.name.name get]"
  set newDungeon(levels) "[.newDungeon.size.levels get]"
  set newDungeon(xsize) "[.newDungeon.size.xsize get]"
  set newDungeon(ysize) "[.newDungeon.size.ysize get]"
  if {![Is3Numbers [list $newDungeon(levels) $newDungeon(xsize) $newDungeon(ysize)]]} {
    AlertBox "Bad dungeon size values, re-enter!"
    return
  }
  set newDungeon(comments) "[.newDungeon.comments.frame.text2 get 1.0 end]"
  set newDungeon(button) {ok}
  if {"[info commands XFDestroy]" != ""} {
    catch "XFDestroy .newDungeon"
  } else {
    catch "destroy .newDungeon"
  }
}

# Procedure: MasterEditDungeonComments
proc MasterEditDungeonComments {} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return}
  if {[EditComments $CurrentMasterDungeon(handle) comments]} {
    set CurrentMasterDungeon(isdirty) 1
  }
}

# Procedure: MasterEditGameNotes
proc MasterEditGameNotes {} {
  global CurrentMasterGame
  if {$CurrentMasterGame(handle) == {}} {return}
  if {[EditComments $CurrentMasterGame(handle) notes]} {
    set CurrentMasterGame(isdirty) 1
  }
}

# Procedure: EditComments
proc EditComments {handle slot} {

  global newComments
  set newComments(text) {}
  set newComments(button) {}

  # build widget .editComments
  if {"[info procs XFEdit]" != ""} {
    catch "XFDestroy .editComments"
  } {
    catch "destroy .editComments"
  }
  toplevel .editComments 

  # Window manager configurations
  global tkVersion
  wm positionfrom .editComments ""
  wm sizefrom .editComments program
  wm maxsize .editComments 1000 768
  wm minsize .editComments 10 10
  wm title .editComments {Edit Commentary}


  # build widget .editComments.buttons
  frame .editComments.buttons \
    -borderwidth {2}

  # build widget .editComments.buttons.cancel
  button .editComments.buttons.cancel \
    -command {global newComments
set newComments(button) {cancel}
if {"[info commands XFDestroy]" != ""} {
  catch "XFDestroy .editComments"
} else {
  catch "destroy .editComments"
} 
}\
    -text {Cancel}

  # build widget .editComments.buttons.ok
  button .editComments.buttons.ok \
    -command {global newComments
set newComments(text) "[.editComments.frame.text2 get 1.0 end]"
set newComments(button) {ok}
if {"[info commands XFDestroy]" != ""} {
  catch "XFDestroy .editComments"
} else {
  catch "destroy .editComments"
} 
}\
    -text {Ok}

  # build widget .editComments.buttons.help
  button .editComments.buttons.help \
    -text {Help}\
    -command {PopupHelpTopic EditComments}

  # pack widget .editComments.buttons
  pack append .editComments.buttons \
    .editComments.buttons.ok {left frame center expand} \
    .editComments.buttons.cancel {left frame center expand} \
    .editComments.buttons.help {right frame center expand}

  # build widget .editComments.frame
  frame .editComments.frame \
    -relief {raised}

  # build widget .editComments.frame.scrollbar1
  scrollbar .editComments.frame.scrollbar1 \
    -command {.editComments.frame.text2 yview}\
    -relief {raised}

  # build widget .editComments.frame.text2
  text .editComments.frame.text2 \
    -borderwidth {2}\
    -relief {raised}\
    -wrap {none}\
    -yscrollcommand {.editComments.frame.scrollbar1 set}

  # pack widget .editComments.frame
  pack append .editComments.frame \
    .editComments.frame.scrollbar1 {right frame center filly} \
    .editComments.frame.text2 {top frame center expand fill} 

  # pack widget .editComments
  pack append .editComments \
    .editComments.frame {top frame center fill} \
    .editComments.buttons {top frame center fill} 

  .editComments.frame.text2 insert end "[$handle $slot]"

# end of widget tree

  focus .editComments.frame.text2

  update idletasks
  grab .editComments
  tkwait window .editComments

  if {$newComments(button) == {ok}} {
    $handle $slot "$newComments(text)"
    return 1
  } else {
    return 0
  }
}

# Procedure: GetTrickTreasure
proc GetTrickTreasure {which listoption} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return {}}

  global GetTrickTreasureResult
  set GetTrickTreasureResult {}

  # build widget .selectTrickTreasure
  if {"[info procs XFEdit]" != ""} {
    catch "XFDestroy .selectTrickTreasure"
  } {
    catch "destroy .selectTrickTreasure"
  }
  toplevel .selectTrickTreasure 

  # Window manager configurations
  global tkVersion
  wm positionfrom .selectTrickTreasure program
  wm sizefrom .selectTrickTreasure ""
  wm maxsize .selectTrickTreasure 1000 768
  wm minsize .selectTrickTreasure 10 10
  wm title .selectTrickTreasure "Select $which"


  # build widget .selectTrickTreasure.buttons
  frame .selectTrickTreasure.buttons \
    -borderwidth {2}

  # build widget .selectTrickTreasure.buttons.cancel
  button .selectTrickTreasure.buttons.cancel \
    -text {Cancel} \
    -command {SelectTrickTreasureSelectCancel .selectTrickTreasure}

  # build widget .selectTrickTreasure.buttons.ok
  button .selectTrickTreasure.buttons.ok \
    -text {OK} \
    -command {SelectTrickTreasureSelectOk .selectTrickTreasure}

  # build widget .selectTrickTreasure.buttons.help
  button .selectTrickTreasure.buttons.help \
    -text {Help} \
    -command {PopupHelpTopic SelectTrickTreasure}

  # pack widget .selectTrickTreasure.buttons
  pack append .selectTrickTreasure.buttons \
    .selectTrickTreasure.buttons.ok {left frame center expand} \
    .selectTrickTreasure.buttons.cancel {left frame center expand} \
    .selectTrickTreasure.buttons.help {right frame center expand}

  # build widget .selectTrickTreasure.listFrame
  frame .selectTrickTreasure.listFrame 

  # build widget .selectTrickTreasure.listFrame.scrollbar2
  scrollbar .selectTrickTreasure.listFrame.scrollbar2 \
    -command {.selectTrickTreasure.listFrame.listbox1 yview}\
    -relief {raised}

  # build widget .selectTrickTreasure.listFrame.scrollbar3
  scrollbar .selectTrickTreasure.listFrame.scrollbar3 \
    -command {.selectTrickTreasure.listFrame.listbox1 xview}\
    -orient {horizontal}\
    -relief {raised}

  # build widget .selectTrickTreasure.listFrame.list
  listbox .selectTrickTreasure.listFrame.list \
    -geometry {31x10}\
    -relief {raised}\
    -xscrollcommand {.selectTrickTreasure.listFrame.scrollbar3 set}\
    -yscrollcommand {.selectTrickTreasure.listFrame.scrollbar2 set}
  # bindings
  bind .selectTrickTreasure.listFrame.list <Double-Button-1> {SelectTrickTreasureSelectDouble .selectTrickTreasure %W %y}
  bind .selectTrickTreasure.listFrame.list <ButtonPress-1> {SelectTrickTreasureSelect .selectTrickTreasure %W %y}
  bind .selectTrickTreasure.listFrame.list <Button1-Motion> {SelectTrickTreasureSelect .selectTrickTreasure %W %y}
  bind .selectTrickTreasure.listFrame.list <Shift-Button1-Motion> {SelectTrickTreasureSelect .selectTrickTreasure %W %y}
  bind .selectTrickTreasure.listFrame.list <Shift-ButtonPress-1> {SelectTrickTreasureSelect .selectTrickTreasure %W %y}


  # pack widget .selectTrickTreasure.listFrame
  pack append .selectTrickTreasure.listFrame \
    .selectTrickTreasure.listFrame.scrollbar2 {right frame center filly} \
    .selectTrickTreasure.listFrame.list {top frame center expand fill} \
    .selectTrickTreasure.listFrame.scrollbar3 {bottom frame center fillx} 

  # build widget .selectTrickTreasure.selected
  frame .selectTrickTreasure.selected \
    -borderwidth {2}

  # build widget .selectTrickTreasure.selected.label5
  label .selectTrickTreasure.selected.label5 \
    -text "Selected $which"

  # build widget .selectTrickTreasure.selected.selection
  entry .selectTrickTreasure.selected.selection \
    -relief {sunken}
  # bindings
  bind .selectTrickTreasure.selected.selection <Key-Return> {.selectTrickTreasure.buttons.ok invoke}

  # pack widget .selectTrickTreasure.selected
  pack append .selectTrickTreasure.selected \
    .selectTrickTreasure.selected.label5 {left frame center} \
    .selectTrickTreasure.selected.selection {left frame center expand fillx} 

  # pack widget .selectTrickTreasure
  pack append .selectTrickTreasure \
    .selectTrickTreasure.listFrame {top frame center fill} \
    .selectTrickTreasure.selected {top frame center fillx} \
    .selectTrickTreasure.buttons {top frame center fillx} 

  .selectTrickTreasure.selected.selection insert end {}

  set items [$CurrentMasterDungeon(handle) $listoption]
  set next {}
  if {$listoption == "mastertricklist"} {
    set next nexttrick
  } else {
    set next nexttreasure
  }
  while {$items != {}} {
    set nextelt [$items $next]
    set item [$items handle]
    .selectTrickTreasure.listFrame.list insert end "$items - [$item name]"
    set items $nextelt
  }

  focus .selectTrickTreasure.selected.selection
    
# end of widget tree

  update idletasks
  grab .selectTrickTreasure
  tkwait window .selectTrickTreasure

  return $GetTrickTreasureResult

}

# Procedure: SelectTrickTreasureSelectCancel
proc SelectTrickTreasureSelectCancel {toplevel} {
  if {"[info commands XFDestroy]" != ""} {
    catch "XFDestroy $toplevel"
  } else {
    catch "destroy $toplevel"
  }
  global GetTrickTreasureResult
  set GetTrickTreasureResult {}
}

# Procedure: SelectTrickTreasureSelectOk
proc SelectTrickTreasureSelectOk {toplevel} {
  global GetTrickTreasureResult
  set GetTrickTreasureResult "[lindex [$toplevel.selected.selection get] 0]"
  if {"[info commands XFDestroy]" != ""} {
    catch "XFDestroy $toplevel"
  } else {
    catch "destroy $toplevel"
  }
}

# Procedure: SelectTrickTreasureSelectDouble
proc SelectTrickTreasureSelectDouble {top W y} {
  SelectTrickTreasureSelect $top $W $y
  SelectTrickTreasureSelectOk $top
}

# Procedure: SelectTrickTreasureSelect
proc SelectTrickTreasureSelect {top W y} {
  SelectTrickTreasureSelectOne $W $y
  set nearest [$W nearest $y]
  set selection "[$W get $nearest]"
  $top.selected.selection delete 0 end
  $top.selected.selection insert end "$selection"
}

# Procedure: SelectTrickTreasureSelectOne
proc SelectTrickTreasureSelectOne {W y} {
  set nearest [$W nearest $y]
  if {$nearest >= 0} {
    $W select from $nearest
    $W select to $nearest
  }
}

# Procedure: SelectEncumbrence
proc SelectEncumbrence {encumbrenceList} {
  global CurrentMasterDungeon
  if {$CurrentMasterDungeon(handle) == {}} {return {}}

  global SelectEncumbrenceResult
  set SelectEncumbrenceResult {}

  # build widget .selectEncumbrence
  if {"[info procs XFEdit]" != ""} {
    catch "XFDestroy .selectEncumbrence"
  } {
    catch "destroy .selectEncumbrence"
  }
  toplevel .selectEncumbrence 

  # Window manager configurations
  global tkVersion
  wm positionfrom .selectEncumbrence program
  wm sizefrom .selectEncumbrence ""
  wm maxsize .selectEncumbrence 1000 768
  wm minsize .selectEncumbrence 10 10
  wm title .selectEncumbrence "Select Encumbrence"


  # build widget .selectEncumbrence.buttons
  frame .selectEncumbrence.buttons \
    -borderwidth {2}

  # build widget .selectEncumbrence.buttons.cancel
  button .selectEncumbrence.buttons.cancel \
    -text {Cancel} \
    -command {SelectEncumbrenceSelectCancel .selectEncumbrence}

  # build widget .selectEncumbrence.buttons.ok
  button .selectEncumbrence.buttons.ok \
    -text {OK} \
    -command {SelectEncumbrenceSelectOk .selectEncumbrence}

  # build widget .selectEncumbrence.buttons.help
  button .selectEncumbrence.buttons.help \
    -text {Help} \
    -command {PopupHelpTopic SelectEncumbrence}

  # pack widget .selectEncumbrence.buttons
  pack append .selectEncumbrence.buttons \
    .selectEncumbrence.buttons.ok {left frame center expand} \
    .selectEncumbrence.buttons.cancel {left frame center expand} \
    .selectEncumbrence.buttons.help {right frame center expand}

  # build widget .selectEncumbrence.listFrame
  frame .selectEncumbrence.listFrame 

  # build widget .selectEncumbrence.listFrame.scrollbar2
  scrollbar .selectEncumbrence.listFrame.scrollbar2 \
    -command {.selectEncumbrence.listFrame.listbox1 yview}\
    -relief {raised}

  # build widget .selectEncumbrence.listFrame.scrollbar3
  scrollbar .selectEncumbrence.listFrame.scrollbar3 \
    -command {.selectEncumbrence.listFrame.listbox1 xview}\
    -orient {horizontal}\
    -relief {raised}

  # build widget .selectEncumbrence.listFrame.list
  listbox .selectEncumbrence.listFrame.list \
    -geometry {31x10}\
    -relief {raised}\
    -xscrollcommand {.selectEncumbrence.listFrame.scrollbar3 set}\
    -yscrollcommand {.selectEncumbrence.listFrame.scrollbar2 set}
  # bindings
  bind .selectEncumbrence.listFrame.list <Double-Button-1> {SelectEncumbrenceSelectDouble .selectEncumbrence %W %y}
  bind .selectEncumbrence.listFrame.list <ButtonPress-1> {SelectEncumbrenceSelect .selectEncumbrence %W %y}
  bind .selectEncumbrence.listFrame.list <Button1-Motion> {SelectEncumbrenceSelect .selectEncumbrence %W %y}
  bind .selectEncumbrence.listFrame.list <Shift-Button1-Motion> {SelectEncumbrenceSelect .selectEncumbrence %W %y}
  bind .selectEncumbrence.listFrame.list <Shift-ButtonPress-1> {SelectEncumbrenceSelect .selectEncumbrence %W %y}


  # pack widget .selectEncumbrence.listFrame
  pack append .selectEncumbrence.listFrame \
    .selectEncumbrence.listFrame.scrollbar2 {right frame center filly} \
    .selectEncumbrence.listFrame.list {top frame center expand fill} \
    .selectEncumbrence.listFrame.scrollbar3 {bottom frame center fillx} 

  # build widget .selectEncumbrence.selected
  frame .selectEncumbrence.selected \
    -borderwidth {2}

  # build widget .selectEncumbrence.selected.label5
  label .selectEncumbrence.selected.label5 \
    -text "Selected Encumbrence"

  # build widget .selectEncumbrence.selected.selection
  entry .selectEncumbrence.selected.selection \
    -relief {sunken}
  # bindings
  bind .selectEncumbrence.selected.selection <Key-Return> {.selectEncumbrence.buttons.ok invoke}

  # pack widget .selectEncumbrence.selected
  pack append .selectEncumbrence.selected \
    .selectEncumbrence.selected.label5 {left frame center} \
    .selectEncumbrence.selected.selection {left frame center expand fillx} 

  # pack widget .selectEncumbrence
  pack append .selectEncumbrence \
    .selectEncumbrence.listFrame {top frame center fill} \
    .selectEncumbrence.selected {top frame center fillx} \
    .selectEncumbrence.buttons {top frame center fillx} 

  .selectEncumbrence.selected.selection insert end {}

  foreach i $encumbrenceList {
    .selectEncumbrence.listFrame.list insert end "$i - [$i name]"
  }

  focus .selectEncumbrence.selected.selection
    
# end of widget tree

  update idletasks
  grab .selectEncumbrence
  tkwait window .selectEncumbrence

  return $SelectEncumbrenceResult

}

# Procedure: SelectEncumbrenceSelectCancel
proc SelectEncumbrenceSelectCancel {toplevel} {
  if {"[info commands XFDestroy]" != ""} {
    catch "XFDestroy $toplevel"
  } else {
    catch "destroy $toplevel"
  }
  global SelectEncumbrenceResult
  set SelectEncumbrenceResult {}
}

# Procedure: SelectEncumbrenceSelectOk
proc SelectEncumbrenceSelectOk {toplevel} {
  global SelectEncumbrenceResult
  set SelectEncumbrenceResult "[lindex [$toplevel.selected.selection get] 0]"
  if {"[info commands XFDestroy]" != ""} {
    catch "XFDestroy $toplevel"
  } else {
    catch "destroy $toplevel"
  }
}

# Procedure: SelectEncumbrenceSelectDouble
proc SelectEncumbrenceSelectDouble {top W y} {
  SelectEncumbrenceSelect $top $W $y
  SelectEncumbrenceSelectOk $top
}

# Procedure: SelectEncumbrenceSelect
proc SelectEncumbrenceSelect {top W y} {
  SelectEncumbrenceSelectOne $W $y
  set nearest [$W nearest $y]
  set selection "[$W get $nearest]"
  $top.selected.selection delete 0 end
  $top.selected.selection insert end "$selection"
}

# Procedure: SelectEncumbrenceSelectOne
proc SelectEncumbrenceSelectOne {W y} {
  set nearest [$W nearest $y]
  if {$nearest >= 0} {
    $W select from $nearest
    $W select to $nearest
  }
}



# eof
#

