protected HexField(HexBuffer buffer, string parentName, string name, HexPosition start, int size) {
			this.buffer = buffer;
			this.parentName = parentName;
			IsVisible = true;
			Name = name;
			Span = new HexSpan(start, (ulong)size);
		}

		void CreateHandler(ShowTabContentEventArgs e, HexViewDocumentTabContent content, HexPosition? fileOffset, AddressReference addrRef) {
			if (!e.Success)
				return;

			Debug.Assert(e.Tab.Content == content);
			var uiContext = e.Tab.UIContext as HexViewDocumentTabUIContext;
			Debug.Assert(uiContext != null);
			if (uiContext == null || fileOffset == null)
				return;

			var start = fileOffset.Value;
			var end = HexPosition.Min(start + addrRef.Length, HexPosition.MaxEndPosition);
			if (!IsVisible(uiContext.HexView, start, end)) {
				uiContext.HexView.Options.SetOptionValue(DefaultHexViewOptions.StartPositionId, uiContext.HexView.Buffer.Span.Start);
				uiContext.HexView.Options.SetOptionValue(DefaultHexViewOptions.EndPositionId, uiContext.HexView.Buffer.Span.End);
				RedisplayHexLines(uiContext.HexView);
				if (!IsVisible(uiContext.HexView, start, end))
					return;
			}
			if (e.HasMovedCaret)
				return;

			if (!uiContext.HexView.VisualElement.IsLoaded) {
				RoutedEventHandler loaded = null;
				loaded = (s, e2) => {
					uiContext.HexView.VisualElement.Loaded -= loaded;
					InitializeHexView(uiContext.HexView, start, end);
				};
				uiContext.HexView.VisualElement.Loaded += loaded;
			}
			else
				InitializeHexView(uiContext.HexView, start, end);
			e.HasMovedCaret = true;
		}

		/// <summary>
		/// Gets all tooltips
		/// </summary>
		/// <param name="position">Position</param>
		/// <returns></returns>
		public IEnumerable<HexStructureInfoProviderAndData<object>> GetToolTips(HexPosition position) {
			foreach (var provider in Providers) {
				var toolTip = provider.GetToolTip(position);
				if (toolTip != null)
					yield return new HexStructureInfoProviderAndData<object>(provider, toolTip);
			}
		}

		/// <summary>
		/// Gets all references
		/// </summary>
		/// <param name="position">Position</param>
		/// <returns></returns>
		public IEnumerable<HexStructureInfoProviderAndData<object>> GetReferences(HexPosition position) {
			foreach (var provider in Providers) {
				var reference = provider.GetReference(position);
				if (reference != null)
					yield return new HexStructureInfoProviderAndData<object>(provider, reference);
			}
		}

		public static void Write(HexBuffer buffer, HexPosition position, byte[] data) {
			if (buffer == null)
				throw new ArgumentNullException(nameof(buffer));
			if (data == null || data.Length == 0)
				return;
			buffer.Replace(position, data);
		}

			public ModuleInfo(IntPtr handle, HexPosition addr, uint size, string filename, bool memoryLayout) {
				ProcessHandle = handle;
				Address = addr;
				Size = size;
				Filename = filename;
				MemoryLayout = memoryLayout;
			}

		public HexBufferLineImpl(HexBufferLineFormatter hexBufferLineFormatter, HexPosition lineNumber, ReadOnlyCollection<HexColumnType> columnOrder, HexBufferSpan bufferSpan, HexBytes hexBytes, string text, bool isOffsetColumnPresent, bool isValuesColumnPresent, bool isAsciiColumnPresent, HexPosition logicalOffset, HexCellCollection valueCells, HexCellCollection asciiCells, VST.Span offsetSpan, VST.Span fullValuesSpan, VST.Span visibleValuesSpan, VST.Span fullAsciiSpan, VST.Span visibleAsciiSpan) {
			if (hexBufferLineFormatter == null)
				throw new ArgumentNullException(nameof(hexBufferLineFormatter));
			if (columnOrder == null)
				throw new ArgumentNullException(nameof(columnOrder));
			if (bufferSpan.IsDefault)
				throw new ArgumentException();
			if (hexBytes.IsDefault)
				throw new ArgumentException();
			if (text == null)
				throw new ArgumentNullException(nameof(text));
			if (valueCells.IsDefault)
				throw new ArgumentNullException(nameof(valueCells));
			if (asciiCells.IsDefault)
				throw new ArgumentNullException(nameof(asciiCells));
			LineProvider = hexBufferLineFormatter;
			LineNumber = lineNumber;
			ColumnOrder = columnOrder;
			BufferSpan = bufferSpan;
			HexBytes = hexBytes;
			Text = text;
			IsOffsetColumnPresent = isOffsetColumnPresent;
			IsValuesColumnPresent = isValuesColumnPresent;
			IsAsciiColumnPresent = isAsciiColumnPresent;
			LogicalOffset = logicalOffset;
			ValueCells = valueCells;
			AsciiCells = asciiCells;
			this.offsetSpan = offsetSpan;
			this.fullValuesSpan = fullValuesSpan;
			this.visibleValuesSpan = visibleValuesSpan;
			this.fullAsciiSpan = fullAsciiSpan;
			this.visibleAsciiSpan = visibleAsciiSpan;
		}

		public override int TryReadByte(HexPosition position) {
			Debug.Assert(position < HexPosition.MaxEndPosition);
			var pos = position.ToUInt64();
			var d = data;
			if (pos >= (ulong)d.LongLength)
				return -1;
			return d[pos];
		}

		public override sbyte ReadSByte(HexPosition position) {
			Debug.Assert(position < HexPosition.MaxEndPosition);
			var pos = position.ToUInt64();
			var d = data;
			if (pos >= (ulong)d.LongLength)
				return 0;
			return (sbyte)d[pos];
		}

		public override ushort ReadUInt16(HexPosition position) {
			Debug.Assert(position < HexPosition.MaxEndPosition);
			var pos = position.ToUInt64();
			var d = data;
			if (pos + 1 < pos || pos + 1 >= (ulong)d.LongLength)
				return pos < (ulong)d.LongLength ? d[pos] : (ushort)0;

			return (ushort)(d[pos] | (d[pos + 1] << 8));
		}

 private static HexPosition[] reconstructPath(Dictionary<HexPosition,HexPosition> cameFrom, HexPosition final, int size)
 {
     HexPosition[] path = new HexPosition[size];
     path [size - 1] = final;
     for (int i = size-2; i >=0; --i) {
         cameFrom.TryGetValue(path[i+1],out path[i]);
     }
     return path;
 }

		public SelectVM(HexPosition start, HexPosition end, HexPosition min, HexPosition max) {
			StartVM = new HexPositionVM(start, a => HasErrorUpdated(), false) {
				Min = min,
				Max = max,
			};
			EndVM = new HexPositionVM(end, a => HasErrorUpdated(), false) {
				Min = min,
				Max = max,
			};
		}

		protected MetaDataTableVM(object owner, HexBuffer buffer, HexPosition startOffset, MDTable mdTable, HexSpan stringsHeapSpan, HexSpan guidHeapSpan) {
			this.buffer = buffer;
			this.stringsHeapSpan = stringsHeapSpan;
			this.guidHeapSpan = guidHeapSpan;
			Owner = owner;
			Span = new HexSpan(startOffset, (ulong)mdTable.Rows * mdTable.RowSize);
			Rows = mdTable.Rows;
			TableInfo = CreateTableInfo(mdTable.TableInfo);
			Collection = new VirtualizedList<MetaDataTableRecordVM>((int)Rows, CreateItem);
		}

		/// <summary>
		/// Gets information about a position in the stream
		/// </summary>
		/// <param name="position">Position</param>
		/// <param name="validSpan">Span of all valid data</param>
		/// <returns></returns>
		protected HexSpanInfo GetSpanInfo(HexPosition position, HexSpan validSpan) {
			if (position >= HexPosition.MaxEndPosition)
				throw new ArgumentOutOfRangeException(nameof(position));
			if (position >= validSpan.End)
				return new HexSpanInfo(HexSpan.FromBounds(validSpan.End, HexPosition.MaxEndPosition), HexSpanInfoFlags.None);
			else if (position < validSpan.Start)
				return new HexSpanInfo(HexSpan.FromBounds(HexPosition.Zero, validSpan.Start), HexSpanInfoFlags.None);
			else
				return new HexSpanInfo(validSpan, HexSpanInfoFlags.HasData);
		}

		public ImageSectionHeaderVM(object owner, HexBuffer buffer, HexPosition startOffset)
			: base(owner) {
			NameVM = new StringHexField(buffer, Name, "Name", startOffset + 0, Encoding.UTF8, 8);
			VirtualSizeVM = new UInt32HexField(buffer, Name, "VirtualSize", startOffset + 8);
			VirtualAddressVM = new UInt32HexField(buffer, Name, "VirtualAddress", startOffset + 0x0C);
			SizeOfRawDataVM = new UInt32HexField(buffer, Name, "SizeOfRawData", startOffset + 0x10);
			PointerToRawDataVM = new UInt32HexField(buffer, Name, "PointerToRawData", startOffset + 0x14);
			PointerToRelocationsVM = new UInt32HexField(buffer, Name, "PointerToRelocations", startOffset + 0x18);
			PointerToLinenumbersVM = new UInt32HexField(buffer, Name, "PointerToLinenumbers", startOffset + 0x1C);
			NumberOfRelocationsVM = new UInt16HexField(buffer, Name, "NumberOfRelocations", startOffset + 0x20);
			NumberOfLinenumbersVM = new UInt16HexField(buffer, Name, "NumberOfLinenumbers", startOffset + 0x22);
			CharacteristicsVM = new UInt32FlagsHexField(buffer, Name, "Characteristics", startOffset + 0x24);
			CharacteristicsVM.Add(new BooleanHexBitField("TYPE_DSECT", 0));
			CharacteristicsVM.Add(new BooleanHexBitField("TYPE_NOLOAD", 1));
			CharacteristicsVM.Add(new BooleanHexBitField("TYPE_GROUP", 2));
			CharacteristicsVM.Add(new BooleanHexBitField("TYPE_NO_PAD", 3));
			CharacteristicsVM.Add(new BooleanHexBitField("TYPE_COPY", 4));
			CharacteristicsVM.Add(new BooleanHexBitField("CNT_CODE", 5));
			CharacteristicsVM.Add(new BooleanHexBitField("CNT_INITIALIZED_DATA", 6));
			CharacteristicsVM.Add(new BooleanHexBitField("CNT_UNINITIALIZED_DATA", 7));
			CharacteristicsVM.Add(new BooleanHexBitField("LNK_OTHER", 8));
			CharacteristicsVM.Add(new BooleanHexBitField("LNK_INFO", 9));
			CharacteristicsVM.Add(new BooleanHexBitField("TYPE_OVER", 10));
			CharacteristicsVM.Add(new BooleanHexBitField("LNK_REMOVE", 11));
			CharacteristicsVM.Add(new BooleanHexBitField("LNK_COMDAT", 12));
			CharacteristicsVM.Add(new BooleanHexBitField("RESERVED", 13));
			CharacteristicsVM.Add(new BooleanHexBitField("NO_DEFER_SPEC_EXC", 14));
			CharacteristicsVM.Add(new BooleanHexBitField("GPREL", 15));
			CharacteristicsVM.Add(new BooleanHexBitField("MEM_SYSHEAP", 16));
			CharacteristicsVM.Add(new BooleanHexBitField("MEM_PURGEABLE", 17));
			CharacteristicsVM.Add(new BooleanHexBitField("MEM_LOCKED", 18));
			CharacteristicsVM.Add(new BooleanHexBitField("MEM_PRELOAD", 19));
			CharacteristicsVM.Add(new IntegerHexBitField("Alignment", 20, 4, AlignInfos));
			CharacteristicsVM.Add(new BooleanHexBitField("LNK_NRELOC_OVFL", 24));
			CharacteristicsVM.Add(new BooleanHexBitField("MEM_DISCARDABLE", 25));
			CharacteristicsVM.Add(new BooleanHexBitField("MEM_NOT_CACHED", 26));
			CharacteristicsVM.Add(new BooleanHexBitField("MEM_NOT_PAGED", 27));
			CharacteristicsVM.Add(new BooleanHexBitField("MEM_SHARED", 28));
			CharacteristicsVM.Add(new BooleanHexBitField("MEM_EXECUTE", 29));
			CharacteristicsVM.Add(new BooleanHexBitField("MEM_READ", 30));
			CharacteristicsVM.Add(new BooleanHexBitField("MEM_WRITE", 31));

			hexFields = new HexField[] {
				NameVM,
				VirtualSizeVM,
				VirtualAddressVM,
				SizeOfRawDataVM,
				PointerToRawDataVM,
				PointerToRelocationsVM,
				PointerToLinenumbersVM,
				NumberOfRelocationsVM,
				NumberOfLinenumbersVM,
				CharacteristicsVM,
			};
		}

		public StorageStreamVM(HexBuffer buffer, HexPosition startOffset, int stringLen) {
			IOffsetVM = new UInt32HexField(buffer, Name, "iOffset", startOffset + 0);
			ISizeVM = new UInt32HexField(buffer, Name, "iSize", startOffset + 4);
			RCNameVM = new StringHexField(buffer, Name, "rcName", startOffset + 8, Encoding.ASCII, stringLen);

			hexFields = new HexField[] {
				IOffsetVM,
				ISizeVM,
				RCNameVM,
			};
		}

 //Start from start, move to within distance of goal within max steps.
 public static HexPosition[] search(HexPosition start, HexPosition goal, int max, int distance = 0)
 {
     max += distance; //Now it's the maximum distance to the goal, instead of just the maximum number of steps.
                      //HashSet<HexPosition> closedSet = new HashSet<HexPosition>();	// The set of nodes already evaluated.
                      //HashSet<HexPosition> openSet = new HashSet<HexPosition>(start);	// The set of tentative nodes to be evaluated, initially containing the start node
     Dictionary<HexPosition, HexPosition> cameFrom = new Dictionary<HexPosition, HexPosition>(); // The map of navigated nodes.
     Dictionary<HexPosition, int> gScore = new Dictionary<HexPosition, int>();   // Cost from start along best known path. Domain is the open and closed sets.
     Dictionary<HexPosition, int> fScore = new Dictionary<HexPosition, int>();   // Estimated total cost from start to goal through y. Domain is the open set.
     gScore.Add(start, 0);
     fScore.Add(start, start.dist(goal));
     while (fScore.Count > 0)
     {
         HexPosition current = getMin(fScore);
         if (current.dist(goal) <= distance)
         {
             int length = 0;
             gScore.TryGetValue(current, out length);
             return reconstructPath(cameFrom, current, length + 1);
         }
         fScore.Remove(current);
         foreach (HexPosition neighbor in current.Neighbors)
         {
             if (neighbor.containsKey("Obstacle") || neighbor.containsKey("Unit"))
             {
                 continue;   //Make this more general.
             }
             if (gScore.ContainsKey(neighbor) && !fScore.ContainsKey(neighbor))
             {
                 continue;
             }
             int tentativeGScore = 0;
             gScore.TryGetValue(current, out tentativeGScore);
             ++tentativeGScore;
             if (tentativeGScore > max)
             {
                 continue;
             }
             int neighborGScore = 0;
             gScore.TryGetValue(current, out neighborGScore);
             if (!fScore.ContainsKey(neighbor) || tentativeGScore < neighborGScore)
             {
                 int newFScore = tentativeGScore + neighbor.dist(goal);
                 if (newFScore > max)
                 {
                     continue;
                 }
                 cameFrom.Add(neighbor, current);
                 gScore.Add(neighbor, tentativeGScore);
                 fScore.Add(neighbor, newFScore);
             }
         }
     }
     return new HexPosition[0] { };
 }

 public void build_on(int selected, HexPosition destination)
 {
     Debug.Log ("Selected " + selected.ToString ());
     Settlement unit = this.buildings[selected];
     GameObject unit_go = (GameObject) Instantiate (unit.gameObject, destination.getPosition(), new Quaternion());
     unit_go.transform.parent = GameObject.FindGameObjectWithTag ("Units").transform;
     grid.AddUnit (unit);
     unit.SetGrid (grid);
     grid.ai.add_unit (unit);
     this.state = State.DONE;
     grid.state_change (this);
 }

		public StorageHeaderVM(HexBuffer buffer, HexPosition startOffset) {
			FFlagsVM = new ByteFlagsHexField(buffer, Name, "fFlags", startOffset + 0);
			FFlagsVM.Add(new BooleanHexBitField("ExtraData", 0));
			PadVM = new ByteHexField(buffer, Name, "pad", startOffset + 1);
			IStreamsVM = new UInt16HexField(buffer, Name, "iStreams", startOffset + 2);

			hexFields = new HexField[] {
				FFlagsVM,
				PadVM,
				IStreamsVM,
			};
		}

		public void FormatOffset(StringBuilder dest, HexPosition position) {
			var offset = position.ToUInt64() << (64 - bitSize);
			dest.Append(prefix);
			for (int i = 0; i < bitSize; i += 4, offset <<= 4) {
				var nibble = (offset >> 60) & 0x0F;
				if (nibble < 10)
					dest.Append((char)('0' + nibble));
				else
					dest.Append((char)((lowerCaseHex ? 'a' : 'A') + nibble - 10));
			}
			dest.Append(suffix);
		}