mirror of
https://github.com/claunia/SabreTools.git
synced 2025-12-16 19:14:27 +00:00
605 lines
30 KiB
C#
605 lines
30 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Xml;
|
|
using SabreTools.Core;
|
|
using SabreTools.Core.Tools;
|
|
using SabreTools.DatItems;
|
|
using SabreTools.DatItems.Formats;
|
|
using SabreTools.IO;
|
|
|
|
namespace SabreTools.DatFiles.Formats
|
|
{
|
|
/// <summary>
|
|
/// Represents writing a MAME XML DAT
|
|
/// </summary>
|
|
internal partial class Listxml : DatFile
|
|
{
|
|
/// <inheritdoc/>
|
|
protected override ItemType[] GetSupportedTypes()
|
|
{
|
|
return new ItemType[]
|
|
{
|
|
ItemType.Adjuster,
|
|
ItemType.BiosSet,
|
|
ItemType.Chip,
|
|
ItemType.Condition,
|
|
ItemType.Configuration,
|
|
ItemType.Device,
|
|
ItemType.DeviceReference,
|
|
ItemType.DipSwitch,
|
|
ItemType.Disk,
|
|
ItemType.Display,
|
|
ItemType.Driver,
|
|
ItemType.Feature,
|
|
ItemType.Input,
|
|
ItemType.Port,
|
|
ItemType.RamOption,
|
|
ItemType.Rom,
|
|
ItemType.Sample,
|
|
ItemType.Slot,
|
|
ItemType.SoftwareList,
|
|
ItemType.Sound,
|
|
};
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
protected override List<DatItemField> GetMissingRequiredFields(DatItem datItem)
|
|
{
|
|
// TODO: Check required fields
|
|
return null;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
|
|
{
|
|
try
|
|
{
|
|
logger.User($"Writing to '{outfile}'...");
|
|
FileStream fs = System.IO.File.Create(outfile);
|
|
|
|
// If we get back null for some reason, just log and return
|
|
if (fs == null)
|
|
{
|
|
logger.Warning($"File '{outfile}' could not be created for writing! Please check to see if the file is writable");
|
|
return false;
|
|
}
|
|
|
|
XmlTextWriter xtw = new(fs, new UTF8Encoding(false))
|
|
{
|
|
Formatting = Formatting.Indented,
|
|
IndentChar = '\t',
|
|
Indentation = 1
|
|
};
|
|
|
|
// Write out the header
|
|
WriteHeader(xtw);
|
|
|
|
// Write out each of the machines and roms
|
|
string lastgame = null;
|
|
|
|
// Use a sorted list of games to output
|
|
foreach (string key in Items.SortedKeys)
|
|
{
|
|
ConcurrentList<DatItem> datItems = Items.FilteredItems(key);
|
|
|
|
// If this machine doesn't contain any writable items, skip
|
|
if (!ContainsWritable(datItems))
|
|
continue;
|
|
|
|
// Resolve the names in the block
|
|
datItems = DatItem.ResolveNames(datItems);
|
|
|
|
for (int index = 0; index < datItems.Count; index++)
|
|
{
|
|
DatItem datItem = datItems[index];
|
|
|
|
// If we have a different game and we're not at the start of the list, output the end of last item
|
|
if (lastgame != null && lastgame.ToLowerInvariant() != datItem.Machine.Name.ToLowerInvariant())
|
|
WriteEndGame(xtw);
|
|
|
|
// If we have a new game, output the beginning of the new item
|
|
if (lastgame == null || lastgame.ToLowerInvariant() != datItem.Machine.Name.ToLowerInvariant())
|
|
WriteStartGame(xtw, datItem);
|
|
|
|
// Check for a "null" item
|
|
datItem = ProcessNullifiedItem(datItem);
|
|
|
|
// Write out the item if we're not ignoring
|
|
if (!ShouldIgnore(datItem, ignoreblanks))
|
|
WriteDatItem(xtw, datItem);
|
|
|
|
// Set the new data to compare against
|
|
lastgame = datItem.Machine.Name;
|
|
}
|
|
}
|
|
|
|
// Write the file footer out
|
|
WriteFooter(xtw);
|
|
|
|
logger.User($"'{outfile}' written!{Environment.NewLine}");
|
|
xtw.Dispose();
|
|
fs.Dispose();
|
|
}
|
|
catch (Exception ex) when (!throwOnError)
|
|
{
|
|
logger.Error(ex);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write out DAT header using the supplied StreamWriter
|
|
/// </summary>
|
|
/// <param name="xtw">XmlTextWriter to output to</param>
|
|
private void WriteHeader(XmlTextWriter xtw)
|
|
{
|
|
xtw.WriteStartDocument();
|
|
|
|
xtw.WriteStartElement("mame");
|
|
xtw.WriteRequiredAttributeString("build", Header.Name);
|
|
xtw.WriteOptionalAttributeString("debug", Header.Debug.FromYesNo());
|
|
xtw.WriteOptionalAttributeString("mameconfig", Header.MameConfig);
|
|
|
|
xtw.Flush();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write out Game start using the supplied StreamWriter
|
|
/// </summary>
|
|
/// <param name="xtw">XmlTextWriter to output to</param>
|
|
/// <param name="datItem">DatItem object to be output</param>
|
|
/// <returns>True if the data was written, false on error</returns>
|
|
private void WriteStartGame(XmlTextWriter xtw, DatItem datItem)
|
|
{
|
|
// No game should start with a path separator
|
|
datItem.Machine.Name = datItem.Machine.Name.TrimStart(Path.DirectorySeparatorChar);
|
|
|
|
// Build the state
|
|
xtw.WriteStartElement("machine");
|
|
xtw.WriteRequiredAttributeString("name", datItem.Machine.Name);
|
|
xtw.WriteOptionalAttributeString("sourcefile", datItem.Machine.SourceFile);
|
|
|
|
if (datItem.Machine.MachineType.HasFlag(MachineType.Bios))
|
|
xtw.WriteAttributeString("isbios", "yes");
|
|
if (datItem.Machine.MachineType.HasFlag(MachineType.Device))
|
|
xtw.WriteAttributeString("isdevice", "yes");
|
|
if (datItem.Machine.MachineType.HasFlag(MachineType.Mechanical))
|
|
xtw.WriteAttributeString("ismechanical", "yes");
|
|
|
|
xtw.WriteOptionalAttributeString("runnable", datItem.Machine.Runnable.FromRunnable());
|
|
|
|
if (!string.Equals(datItem.Machine.Name, datItem.Machine.CloneOf, StringComparison.OrdinalIgnoreCase))
|
|
xtw.WriteOptionalAttributeString("cloneof", datItem.Machine.CloneOf);
|
|
if (!string.Equals(datItem.Machine.Name, datItem.Machine.RomOf, StringComparison.OrdinalIgnoreCase))
|
|
xtw.WriteOptionalAttributeString("romof", datItem.Machine.RomOf);
|
|
if (!string.Equals(datItem.Machine.Name, datItem.Machine.SampleOf, StringComparison.OrdinalIgnoreCase))
|
|
xtw.WriteOptionalAttributeString("sampleof", datItem.Machine.SampleOf);
|
|
|
|
xtw.WriteOptionalElementString("description", datItem.Machine.Description);
|
|
xtw.WriteOptionalElementString("year", datItem.Machine.Year);
|
|
xtw.WriteOptionalElementString("manufacturer", datItem.Machine.Manufacturer);
|
|
xtw.WriteOptionalElementString("history", datItem.Machine.History);
|
|
|
|
xtw.Flush();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write out Game start using the supplied StreamWriter
|
|
/// </summary>
|
|
/// <param name="xtw">XmlTextWriter to output to</param>
|
|
private void WriteEndGame(XmlTextWriter xtw)
|
|
{
|
|
// End machine
|
|
xtw.WriteEndElement();
|
|
|
|
xtw.Flush();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write out DatItem using the supplied StreamWriter
|
|
/// </summary>
|
|
/// <param name="xtw">XmlTextWriter to output to</param>
|
|
/// <param name="datItem">DatItem object to be output</param>
|
|
private void WriteDatItem(XmlTextWriter xtw, DatItem datItem)
|
|
{
|
|
// Pre-process the item name
|
|
ProcessItemName(datItem, true);
|
|
|
|
// Build the state
|
|
switch (datItem.ItemType)
|
|
{
|
|
case ItemType.Adjuster:
|
|
var adjuster = datItem as Adjuster;
|
|
xtw.WriteStartElement("adjuster");
|
|
xtw.WriteRequiredAttributeString("name", adjuster.Name);
|
|
xtw.WriteRequiredAttributeString("default", adjuster.Default.FromYesNo());
|
|
if (adjuster.ConditionsSpecified)
|
|
{
|
|
foreach (var adjusterCondition in adjuster.Conditions)
|
|
{
|
|
xtw.WriteStartElement("condition");
|
|
xtw.WriteRequiredAttributeString("tag", adjusterCondition.Tag);
|
|
xtw.WriteRequiredAttributeString("mask", adjusterCondition.Mask);
|
|
xtw.WriteRequiredAttributeString("relation", adjusterCondition.Relation.FromRelation());
|
|
xtw.WriteRequiredAttributeString("value", adjusterCondition.Value);
|
|
xtw.WriteEndElement();
|
|
}
|
|
}
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.BiosSet:
|
|
var biosSet = datItem as BiosSet;
|
|
xtw.WriteStartElement("biosset");
|
|
xtw.WriteRequiredAttributeString("name", biosSet.Name);
|
|
xtw.WriteRequiredAttributeString("description", biosSet.Description);
|
|
xtw.WriteOptionalAttributeString("default", biosSet.Default?.ToString().ToLowerInvariant());
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.Chip:
|
|
var chip = datItem as Chip;
|
|
xtw.WriteStartElement("chip");
|
|
xtw.WriteRequiredAttributeString("name", chip.Name);
|
|
xtw.WriteOptionalAttributeString("tag", chip.Tag);
|
|
xtw.WriteRequiredAttributeString("type", chip.ChipType.FromChipType());
|
|
xtw.WriteOptionalAttributeString("clock", chip.Clock?.ToString());
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.Condition:
|
|
var condition = datItem as Condition;
|
|
xtw.WriteStartElement("condition");
|
|
xtw.WriteRequiredAttributeString("tag", condition.Tag);
|
|
xtw.WriteRequiredAttributeString("mask", condition.Mask);
|
|
xtw.WriteRequiredAttributeString("relation", condition.Relation.FromRelation());
|
|
xtw.WriteRequiredAttributeString("value", condition.Value);
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.Configuration:
|
|
var configuration = datItem as Configuration;
|
|
xtw.WriteStartElement("configuration");
|
|
xtw.WriteRequiredAttributeString("name", configuration.Name);
|
|
xtw.WriteRequiredAttributeString("tag", configuration.Tag);
|
|
xtw.WriteRequiredAttributeString("mask", configuration.Mask);
|
|
|
|
if (configuration.ConditionsSpecified)
|
|
{
|
|
foreach (var configurationCondition in configuration.Conditions)
|
|
{
|
|
xtw.WriteStartElement("condition");
|
|
xtw.WriteRequiredAttributeString("tag", configurationCondition.Tag);
|
|
xtw.WriteRequiredAttributeString("mask", configurationCondition.Mask);
|
|
xtw.WriteRequiredAttributeString("relation", configurationCondition.Relation.FromRelation());
|
|
xtw.WriteRequiredAttributeString("value", configurationCondition.Value);
|
|
xtw.WriteEndElement();
|
|
}
|
|
}
|
|
if (configuration.LocationsSpecified)
|
|
{
|
|
foreach (var location in configuration.Locations)
|
|
{
|
|
xtw.WriteStartElement("conflocation");
|
|
xtw.WriteRequiredAttributeString("name", location.Name);
|
|
xtw.WriteRequiredAttributeString("number", location.Number?.ToString());
|
|
xtw.WriteOptionalAttributeString("inverted", location.Inverted.FromYesNo());
|
|
xtw.WriteEndElement();
|
|
}
|
|
}
|
|
if (configuration.SettingsSpecified)
|
|
{
|
|
foreach (var setting in configuration.Settings)
|
|
{
|
|
xtw.WriteStartElement("confsetting");
|
|
xtw.WriteRequiredAttributeString("name", setting.Name);
|
|
xtw.WriteRequiredAttributeString("value", setting.Value);
|
|
xtw.WriteOptionalAttributeString("default", setting.Default.FromYesNo());
|
|
if (setting.ConditionsSpecified)
|
|
{
|
|
foreach (var confsettingCondition in setting.Conditions)
|
|
{
|
|
xtw.WriteStartElement("condition");
|
|
xtw.WriteRequiredAttributeString("tag", confsettingCondition.Tag);
|
|
xtw.WriteRequiredAttributeString("mask", confsettingCondition.Mask);
|
|
xtw.WriteRequiredAttributeString("relation", confsettingCondition.Relation.FromRelation());
|
|
xtw.WriteRequiredAttributeString("value", confsettingCondition.Value);
|
|
xtw.WriteEndElement();
|
|
}
|
|
}
|
|
xtw.WriteEndElement();
|
|
}
|
|
}
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.Device:
|
|
var device = datItem as Device;
|
|
xtw.WriteStartElement("device");
|
|
xtw.WriteRequiredAttributeString("type", device.DeviceType.FromDeviceType());
|
|
xtw.WriteOptionalAttributeString("tag", device.Tag);
|
|
xtw.WriteOptionalAttributeString("fixed_image", device.FixedImage);
|
|
xtw.WriteOptionalAttributeString("mandatory", device.Mandatory?.ToString());
|
|
xtw.WriteOptionalAttributeString("interface", device.Interface);
|
|
if (device.InstancesSpecified)
|
|
{
|
|
foreach (var instance in device.Instances)
|
|
{
|
|
xtw.WriteStartElement("instance");
|
|
xtw.WriteRequiredAttributeString("name", instance.Name);
|
|
xtw.WriteRequiredAttributeString("briefname", instance.BriefName);
|
|
xtw.WriteEndElement();
|
|
}
|
|
}
|
|
if (device.ExtensionsSpecified)
|
|
{
|
|
foreach (var extension in device.Extensions)
|
|
{
|
|
xtw.WriteStartElement("extension");
|
|
xtw.WriteRequiredAttributeString("name", extension.Name);
|
|
xtw.WriteEndElement();
|
|
}
|
|
}
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.DeviceReference:
|
|
var deviceRef = datItem as DeviceReference;
|
|
xtw.WriteStartElement("device_ref");
|
|
xtw.WriteRequiredAttributeString("name", deviceRef.Name);
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.DipSwitch:
|
|
var dipSwitch = datItem as DipSwitch;
|
|
xtw.WriteStartElement("dipswitch");
|
|
xtw.WriteRequiredAttributeString("name", dipSwitch.Name);
|
|
xtw.WriteRequiredAttributeString("tag", dipSwitch.Tag);
|
|
xtw.WriteRequiredAttributeString("mask", dipSwitch.Mask);
|
|
if (dipSwitch.ConditionsSpecified)
|
|
{
|
|
foreach (var dipSwitchCondition in dipSwitch.Conditions)
|
|
{
|
|
xtw.WriteStartElement("condition");
|
|
xtw.WriteRequiredAttributeString("tag", dipSwitchCondition.Tag);
|
|
xtw.WriteRequiredAttributeString("mask", dipSwitchCondition.Mask);
|
|
xtw.WriteRequiredAttributeString("relation", dipSwitchCondition.Relation.FromRelation());
|
|
xtw.WriteRequiredAttributeString("value", dipSwitchCondition.Value);
|
|
xtw.WriteEndElement();
|
|
}
|
|
}
|
|
if (dipSwitch.LocationsSpecified)
|
|
{
|
|
foreach (var location in dipSwitch.Locations)
|
|
{
|
|
xtw.WriteStartElement("diplocation");
|
|
xtw.WriteRequiredAttributeString("name", location.Name);
|
|
xtw.WriteRequiredAttributeString("number", location.Number?.ToString());
|
|
xtw.WriteOptionalAttributeString("inverted", location.Inverted.FromYesNo());
|
|
xtw.WriteEndElement();
|
|
}
|
|
}
|
|
if (dipSwitch.ValuesSpecified)
|
|
{
|
|
foreach (var value in dipSwitch.Values)
|
|
{
|
|
xtw.WriteStartElement("dipvalue");
|
|
xtw.WriteRequiredAttributeString("name", value.Name);
|
|
xtw.WriteRequiredAttributeString("value", value.Value);
|
|
xtw.WriteOptionalAttributeString("default", value.Default.FromYesNo());
|
|
if (value.ConditionsSpecified)
|
|
{
|
|
foreach (var dipValueCondition in value.Conditions)
|
|
{
|
|
xtw.WriteStartElement("condition");
|
|
xtw.WriteRequiredAttributeString("tag", dipValueCondition.Tag);
|
|
xtw.WriteRequiredAttributeString("mask", dipValueCondition.Mask);
|
|
xtw.WriteRequiredAttributeString("relation", dipValueCondition.Relation.FromRelation());
|
|
xtw.WriteRequiredAttributeString("value", dipValueCondition.Value);
|
|
xtw.WriteEndElement();
|
|
}
|
|
}
|
|
xtw.WriteEndElement();
|
|
}
|
|
}
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.Disk:
|
|
var disk = datItem as Disk;
|
|
xtw.WriteStartElement("disk");
|
|
xtw.WriteRequiredAttributeString("name", disk.Name);
|
|
xtw.WriteOptionalAttributeString("sha1", disk.SHA1?.ToLowerInvariant());
|
|
xtw.WriteOptionalAttributeString("merge", disk.MergeTag);
|
|
xtw.WriteOptionalAttributeString("region", disk.Region);
|
|
xtw.WriteOptionalAttributeString("index", disk.Index);
|
|
xtw.WriteOptionalAttributeString("writable", disk.Writable.FromYesNo());
|
|
if (disk.ItemStatus != ItemStatus.None)
|
|
xtw.WriteOptionalAttributeString("status", disk.ItemStatus.FromItemStatus(false));
|
|
xtw.WriteOptionalAttributeString("optional", disk.Optional.FromYesNo());
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.Display:
|
|
var display = datItem as Display;
|
|
xtw.WriteStartElement("display");
|
|
xtw.WriteOptionalAttributeString("tag", display.Tag);
|
|
xtw.WriteRequiredAttributeString("type", display.DisplayType.FromDisplayType());
|
|
xtw.WriteOptionalAttributeString("rotate", display.Rotate?.ToString());
|
|
xtw.WriteOptionalAttributeString("flipx", display.FlipX.FromYesNo());
|
|
xtw.WriteOptionalAttributeString("width", display.Width?.ToString());
|
|
xtw.WriteOptionalAttributeString("height", display.Height?.ToString());
|
|
xtw.WriteRequiredAttributeString("refresh", display.Refresh?.ToString("N6"));
|
|
xtw.WriteOptionalAttributeString("pixclock", display.PixClock?.ToString());
|
|
xtw.WriteOptionalAttributeString("htotal", display.HTotal?.ToString());
|
|
xtw.WriteOptionalAttributeString("hbend", display.HBEnd?.ToString());
|
|
xtw.WriteOptionalAttributeString("hstart", display.HBStart?.ToString());
|
|
xtw.WriteOptionalAttributeString("vtotal", display.VTotal?.ToString());
|
|
xtw.WriteOptionalAttributeString("vbend", display.VBEnd?.ToString());
|
|
xtw.WriteOptionalAttributeString("vbstart", display.VBStart?.ToString());
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.Driver:
|
|
var driver = datItem as Driver;
|
|
xtw.WriteStartElement("driver");
|
|
xtw.WriteRequiredAttributeString("status", driver.Status.FromSupportStatus());
|
|
xtw.WriteRequiredAttributeString("emulation", driver.Emulation.FromSupportStatus());
|
|
xtw.WriteOptionalAttributeString("cocktail", driver.Cocktail.FromSupportStatus());
|
|
xtw.WriteRequiredAttributeString("savestate", driver.SaveState.FromSupported(true));
|
|
xtw.WriteOptionalAttributeString("requiresartwork", driver.RequiresArtwork.FromYesNo());
|
|
xtw.WriteOptionalAttributeString("unofficial", driver.Unofficial.FromYesNo());
|
|
xtw.WriteOptionalAttributeString("nosoundhardware", driver.NoSoundHardware.FromYesNo());
|
|
xtw.WriteOptionalAttributeString("incomplete", driver.Incomplete.FromYesNo());
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.Feature:
|
|
var feature = datItem as Feature;
|
|
xtw.WriteStartElement("feature");
|
|
xtw.WriteRequiredAttributeString("type", feature.Type.FromFeatureType());
|
|
xtw.WriteOptionalAttributeString("status", feature.Status.FromFeatureStatus());
|
|
xtw.WriteOptionalAttributeString("overall", feature.Overall.FromFeatureStatus());
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.Input:
|
|
var input = datItem as Input;
|
|
xtw.WriteStartElement("input");
|
|
xtw.WriteOptionalAttributeString("service", input.Service.FromYesNo());
|
|
xtw.WriteOptionalAttributeString("tilt", input.Tilt.FromYesNo());
|
|
xtw.WriteRequiredAttributeString("players", input.Players?.ToString());
|
|
xtw.WriteOptionalAttributeString("coins", input.Coins?.ToString());
|
|
if (input.ControlsSpecified)
|
|
{
|
|
foreach (var control in input.Controls)
|
|
{
|
|
xtw.WriteStartElement("control");
|
|
xtw.WriteRequiredAttributeString("type", control.ControlType.FromControlType());
|
|
xtw.WriteOptionalAttributeString("player", control.Player?.ToString());
|
|
xtw.WriteOptionalAttributeString("buttons", control.Buttons?.ToString());
|
|
xtw.WriteOptionalAttributeString("reqbuttons", control.RequiredButtons?.ToString());
|
|
xtw.WriteOptionalAttributeString("minimum", control.Minimum?.ToString());
|
|
xtw.WriteOptionalAttributeString("maximum", control.Maximum?.ToString());
|
|
xtw.WriteOptionalAttributeString("sensitivity", control.Sensitivity?.ToString());
|
|
xtw.WriteOptionalAttributeString("keydelta", control.KeyDelta?.ToString());
|
|
xtw.WriteOptionalAttributeString("reverse", control.Reverse.FromYesNo());
|
|
xtw.WriteOptionalAttributeString("ways", control.Ways);
|
|
xtw.WriteOptionalAttributeString("ways2", control.Ways2);
|
|
xtw.WriteOptionalAttributeString("ways3", control.Ways3);
|
|
xtw.WriteEndElement();
|
|
}
|
|
}
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.Port:
|
|
var port = datItem as Port;
|
|
xtw.WriteStartElement("port");
|
|
xtw.WriteRequiredAttributeString("tag", port.Tag);
|
|
if (port.AnalogsSpecified)
|
|
{
|
|
foreach (var analog in port.Analogs)
|
|
{
|
|
xtw.WriteStartElement("analog");
|
|
xtw.WriteRequiredAttributeString("mask", analog.Mask);
|
|
xtw.WriteEndElement();
|
|
}
|
|
}
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.RamOption:
|
|
var ramOption = datItem as RamOption;
|
|
xtw.WriteStartElement("ramoption");
|
|
xtw.WriteRequiredAttributeString("name", ramOption.Name);
|
|
xtw.WriteOptionalAttributeString("default", ramOption.Default.FromYesNo());
|
|
xtw.WriteRaw(ramOption.Content ?? string.Empty);
|
|
xtw.WriteFullEndElement();
|
|
break;
|
|
|
|
case ItemType.Rom:
|
|
var rom = datItem as Rom;
|
|
xtw.WriteStartElement("rom");
|
|
xtw.WriteRequiredAttributeString("name", rom.Name);
|
|
xtw.WriteOptionalAttributeString("bios", rom.Bios);
|
|
xtw.WriteRequiredAttributeString("size", rom.Size?.ToString());
|
|
xtw.WriteOptionalAttributeString("crc", rom.CRC?.ToLowerInvariant());
|
|
xtw.WriteOptionalAttributeString("sha1", rom.SHA1?.ToLowerInvariant());
|
|
xtw.WriteOptionalAttributeString("merge", rom.MergeTag);
|
|
xtw.WriteOptionalAttributeString("region", rom.Region);
|
|
xtw.WriteOptionalAttributeString("offset", rom.Offset);
|
|
if (rom.ItemStatus != ItemStatus.None)
|
|
xtw.WriteOptionalAttributeString("status", rom.ItemStatus.FromItemStatus(false));
|
|
xtw.WriteOptionalAttributeString("optional", rom.Optional.FromYesNo());
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.Sample:
|
|
var sample = datItem as Sample;
|
|
xtw.WriteStartElement("sample");
|
|
xtw.WriteRequiredAttributeString("name", sample.Name);
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.Slot:
|
|
var slot = datItem as Slot;
|
|
xtw.WriteStartElement("slot");
|
|
xtw.WriteRequiredAttributeString("name", slot.Name);
|
|
if (slot.SlotOptionsSpecified)
|
|
{
|
|
foreach (var slotOption in slot.SlotOptions)
|
|
{
|
|
xtw.WriteStartElement("slotoption");
|
|
xtw.WriteRequiredAttributeString("name", slotOption.Name);
|
|
xtw.WriteRequiredAttributeString("devname", slotOption.DeviceName);
|
|
xtw.WriteOptionalAttributeString("default", slotOption.Default.FromYesNo());
|
|
xtw.WriteEndElement();
|
|
}
|
|
}
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.SoftwareList:
|
|
var softwareList = datItem as DatItems.Formats.SoftwareList;
|
|
xtw.WriteStartElement("softwarelist");
|
|
xtw.WriteRequiredAttributeString("tag", softwareList.Tag);
|
|
xtw.WriteRequiredAttributeString("name", softwareList.Name);
|
|
if (softwareList.Status != SoftwareListStatus.None)
|
|
xtw.WriteRequiredAttributeString("status", softwareList.Status.FromSoftwareListStatus());
|
|
xtw.WriteOptionalAttributeString("filter", softwareList.Filter);
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.Sound:
|
|
var sound = datItem as Sound;
|
|
xtw.WriteStartElement("sound");
|
|
xtw.WriteRequiredAttributeString("channels", sound.Channels?.ToString());
|
|
xtw.WriteEndElement();
|
|
break;
|
|
}
|
|
|
|
xtw.Flush();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write out DAT footer using the supplied StreamWriter
|
|
/// </summary>
|
|
/// <param name="xtw">XmlTextWriter to output to</param>
|
|
private void WriteFooter(XmlTextWriter xtw)
|
|
{
|
|
// End machine
|
|
xtw.WriteEndElement();
|
|
|
|
// End mame
|
|
xtw.WriteEndElement();
|
|
|
|
xtw.Flush();
|
|
}
|
|
}
|
|
}
|