public static DsDocumentInfo? TryLoad(ISettingsSection section) {
			var name = section.Attribute<string>(DOCUMENTINFO_NAME_ATTR);
			var type = section.Attribute<Guid?>(DOCUMENTINFO_TYPE_ATTR) ?? DocumentConstants.DOCUMENTTYPE_FILE;
			if (string.IsNullOrEmpty(name))
				return null;
			return new DsDocumentInfo(name, type);
		}

		public Guid? Serialize(IFileTabContent content, ISettingsSection section) {
			var dc = content as HexFileTabContent;
			if (dc == null)
				return null;

			return GUID_SerializedContent;
		}

		public static void Serialize(ISettingsSection section, StackedContentState state) {
			section.Attribute(ISHORIZONTAL_ATTR, state.IsHorizontal);
			foreach (var length in state.RowsCols) {
				var lengthSect = section.CreateSection(LENGTH_SECTION);
				lengthSect.Attribute(LENGTH_ATTR, length);
			}
		}

		public MainWindowControlState Read(ISettingsSection section) {
			HorizontalContentState = StackedContentStateSerializer.TryDeserialize(section.GetOrCreateSection(HORIZONTALCONTENT_SECT));
			VerticalContentState = StackedContentStateSerializer.TryDeserialize(section.GetOrCreateSection(VERTICALCONTENT_SECT));

			foreach (var twSect in section.SectionsWithName(TOOLWINDOWUI_SECT)) {
				var state = ToolWindowUIState.TryDeserialize(twSect);
				if (state == null)
					continue;
				switch (state.Location) {
				case AppToolWindowLocation.Left:	LeftState = state; break;
				case AppToolWindowLocation.Right:	RightState = state; break;
				case AppToolWindowLocation.Top:		TopState = state; break;
				case AppToolWindowLocation.Bottom:	BottomState = state; break;
				}
			}

			foreach (var locSect in section.SectionsWithName(LOCATION_SECT)) {
				var guid = locSect.Attribute<Guid?>(LOCATION_GUID_ATTR);
				var loc = locSect.Attribute<AppToolWindowLocation?>(LOCATION_ATTR);
				if (guid == null || loc == null)
					continue;
				if (!IsValid(loc.Value))
					continue;
				SavedLocations[guid.Value] = loc.Value;
			}

			return this;
		}

		public DocumentTabContent Deserialize(Guid guid, ISettingsSection section, IDocumentTabContentFactoryContext context) {
			if (guid != GUID_SerializedContent)
				return null;

			var filename = section.Attribute<string>("filename");
			return hexViewDocumentTabContentCreator.Value.TryCreate(filename);
		}

        XElement Write(ISettingsSection section, int recursionCounter)
        {
            var xmlSect = new XElement(XmlSettingsConstants.SECTION_NAME);

            if (recursionCounter >= XmlSettingsConstants.MAX_CHILD_DEPTH)
                return xmlSect;

            xmlSect.SetAttributeValue(XmlSettingsConstants.SECTION_ATTRIBUTE_NAME, XmlUtils.EscapeAttributeValue(section.Name));
            foreach (var attr in section.Attributes.OrderBy(a => a.Item1.ToUpperInvariant())) {
                var n = XmlUtils.FilterAttributeName(attr.Item1);
                Debug.Assert(n != null, "Invalid character(s) in section attribute name. Only valid XML attribute names can be used.");
                if (n == null)
                    continue;
                bool b = n == XmlSettingsConstants.SECTION_ATTRIBUTE_NAME;
                Debug.Assert(!b, string.Format("Attribute name '{0}' is reserved for use by the XML writer", XmlSettingsConstants.SECTION_ATTRIBUTE_NAME));
                if (b)
                    continue;
                xmlSect.SetAttributeValue(n, XmlUtils.EscapeAttributeValue(attr.Item2));
            }

            foreach (var childSection in Sort(section.Sections))
                xmlSect.Add(Write(childSection, recursionCounter + 1));

            return xmlSect;
        }

		public static HexBoxUIState Read(ISettingsSection section, HexBoxUIState s) {
			if (s.HexBoxState == null)
				return s;

			s.BytesGroupCount = section.Attribute<int?>("BytesGroupCount");
			s.BytesPerLine = section.Attribute<int?>("BytesPerLine");
			s.UseHexPrefix = section.Attribute<bool?>("UseHexPrefix");
			s.ShowAscii = section.Attribute<bool?>("ShowAscii");
			s.LowerCaseHex = section.Attribute<bool?>("LowerCaseHex");
			s.AsciiEncoding = section.Attribute<AsciiEncoding?>("AsciiEncoding");

			s.HexOffsetSize = section.Attribute<int?>("HexOffsetSize") ?? 0;
			s.UseRelativeOffsets = section.Attribute<bool?>("UseRelativeOffsets") ?? false;
			s.BaseOffset = section.Attribute<ulong?>("BaseOffset") ?? 0;

			s.HexBoxState.TopOffset = section.Attribute<ulong?>("HexBoxState-TopOffset") ?? 0;
			s.HexBoxState.Column = section.Attribute<int?>("HexBoxState-Column") ?? 0;
			s.HexBoxState.StartOffset = section.Attribute<ulong?>("HexBoxState-StartOffset") ?? 0;
			s.HexBoxState.EndOffset = section.Attribute<ulong?>("HexBoxState-EndOffset") ?? 0;
			s.HexBoxState.CaretPosition.Offset = section.Attribute<ulong?>("HexBoxState-HexBoxPosition-Offset") ?? 0;
			s.HexBoxState.CaretPosition.Kind = section.Attribute<HexBoxPositionKind?>("HexBoxState-HexBoxPosition-Kind") ?? 0;
			s.HexBoxState.CaretPosition.KindPosition = section.Attribute<byte?>("HexBoxState-HexBoxPosition-KindPosition") ?? 0;

			var from = section.Attribute<ulong?>("HexBoxState-Selection-From");
			var to = section.Attribute<ulong?>("HexBoxState-Selection-To");
			if (from != null && to != null)
				s.HexBoxState.Selection = new HexSelection((ulong)from, (ulong)to);

			return s;
		}

 public SavedWindowState Read(ISettingsSection section)
 {
     Bounds = section.Attribute<Rect?>("Bounds") ?? Rect.Empty;
     IsFullScreen = section.Attribute<bool?>("IsFullScreen") ?? false;
     WindowState = section.Attribute<WindowState?>("WindowState") ?? WindowState.Normal;
     return this;
 }

 public SavedWindowState Write(ISettingsSection section)
 {
     section.Attribute("Bounds", Bounds);
     section.Attribute("IsFullScreen", IsFullScreen);
     section.Attribute("WindowState", WindowState);
     return this;
 }

		public static HexBoxUIState Write(ISettingsSection section, HexBoxUIState s) {
			if (s.HexBoxState == null)
				return s;

			section.Attribute("BytesGroupCount", s.BytesGroupCount);
			section.Attribute("BytesPerLine", s.BytesPerLine);
			section.Attribute("UseHexPrefix", s.UseHexPrefix);
			section.Attribute("ShowAscii", s.ShowAscii);
			section.Attribute("LowerCaseHex", s.LowerCaseHex);
			section.Attribute("AsciiEncoding", s.AsciiEncoding);

			section.Attribute("HexOffsetSize", s.HexOffsetSize);
			section.Attribute("UseRelativeOffsets", s.UseRelativeOffsets);
			section.Attribute("BaseOffset", s.BaseOffset);

			section.Attribute("HexBoxState-TopOffset", s.HexBoxState.TopOffset);
			section.Attribute("HexBoxState-Column", s.HexBoxState.Column);
			section.Attribute("HexBoxState-StartOffset", s.HexBoxState.StartOffset);
			section.Attribute("HexBoxState-EndOffset", s.HexBoxState.EndOffset);
			section.Attribute("HexBoxState-HexBoxPosition-Offset", s.HexBoxState.CaretPosition.Offset);
			section.Attribute("HexBoxState-HexBoxPosition-Kind", s.HexBoxState.CaretPosition.Kind);
			section.Attribute("HexBoxState-HexBoxPosition-KindPosition", s.HexBoxState.CaretPosition.KindPosition);
			if (s.HexBoxState.Selection != null) {
				section.Attribute("HexBoxState-Selection-From", s.HexBoxState.Selection.Value.From);
				section.Attribute("HexBoxState-Selection-To", s.HexBoxState.Selection.Value.To);
			}

			return s;
		}

		public Guid? Serialize(DocumentTabContent content, ISettingsSection section) {
			var hb = content as HexViewDocumentTabContent;
			if (hb == null)
				return null;

			section.Attribute("filename", hb.Filename);
			return GUID_SerializedContent;
		}

		public Guid? Serialize(IFileTabContent content, ISettingsSection section) {
			if (content is AssemblyChildNodeTabContent) {
				// There's nothing else we need to serialize it, but if there were, use 'section'
				// to write the info needed by Deserialize() above.
				return GUID_SerializedContent;
			}
			return null;
		}

		public Guid? Serialize(IFileTabContent content, ISettingsSection section) {
			var dc = content as DecompileFileTabContent;
			if (dc == null)
				return null;

			section.Attribute("Language", dc.Language.UniqueGuid);
			return GUID_SerializedContent;
		}

		public void RemoveSection(ISettingsSection section) {
			Debug.Assert(section != null);
			if (section == null)
				throw new ArgumentNullException(nameof(section));

			bool b = sections.Remove(section);
			Debug.Assert(b);
		}

		public DocumentTabContent Deserialize(Guid guid, ISettingsSection section, IDocumentTabContentFactoryContext context) {
			if (guid != GUID_SerializedContent)
				return null;

			var langGuid = section.Attribute<Guid?>("Language") ?? DecompilerConstants.LANGUAGE_CSHARP;
			var language = DecompilerService.FindOrDefault(langGuid);
			return new DecompileDocumentTabContent(this, context.Nodes, language);
		}

 public static DnSpyFileInfo? TryLoad(ISettingsSection section)
 {
     var name = section.Attribute<string>(FILEINFO_NAME_ATTR);
     var type = section.Attribute<Guid?>(FILEINFO_TYPE_ATTR) ?? FileConstants.FILETYPE_FILE;
     if (string.IsNullOrEmpty(name))
         return null;
     return new DnSpyFileInfo(name, type);
 }

		public DocumentTabContent Deserialize(Guid guid, ISettingsSection section, DocumentTreeNodeData[] nodes) {
			var context = new DocumentTabContentFactoryContext(nodes);
			foreach (var factory in tabContentFactories) {
				var content = factory.Value.Deserialize(guid, section, context);
				if (content != null)
					return content;
			}
			return null;
		}

		public IFileTabContent Deserialize(Guid guid, ISettingsSection section, IFileTabContentFactoryContext context) {
			if (guid != GUID_SerializedContent)
				return null;
			var hexNode = context.Nodes.Length != 1 ? null : context.Nodes[0] as HexNode;
			if (hexNode == null)
				return null;

			return new HexFileTabContent(hexNode);
		}

		public Guid? Serialize(DocumentTabContent content, ISettingsSection section) {
			var nodes = content.Nodes.ToArray();
			var context = new DocumentTabContentFactoryContext(nodes);
			foreach (var factory in tabContentFactories) {
				var guid = factory.Value.Serialize(content, section);
				if (guid != null)
					return guid;
			}
			return null;
		}

 public static FileList Create(ISettingsSection section)
 {
     var fileList = new FileList(section.Attribute<string>(FILELIST_NAME_ATTR));
     foreach (var fileSect in section.SectionsWithName(FILE_SECTION)) {
         var info = DnSpyFileInfoSerializer.TryLoad(fileSect);
         if (info != null)
             fileList.Files.Add(info.Value);
     }
     return fileList;
 }