private bool GetElementInfo(IntermediateSerializer serializer, MemberInfo member, out ElementInfo info)
{
info = new ElementInfo();
// Are we ignoring this property?
if (ReflectionHelpers.GetCustomAttribute(member, typeof(ContentSerializerIgnoreAttribute)) != null)
return false;
var prop = member as PropertyInfo;
var field = member as FieldInfo;
// If we can write or read from it we can skip it.
if (prop != null && (!prop.CanWrite || !prop.CanRead))
return false;
// Default the to member name as the element name.
info.Name = member.Name;
var attrib = ReflectionHelpers.GetCustomAttribute(member, typeof(ContentSerializerAttribute)) as ContentSerializerAttribute;
if (attrib != null)
{
if (!string.IsNullOrEmpty(attrib.ElementName))
info.Name = attrib.ElementName;
}
else if (prop != null)
{
if (!ReflectionHelpers.PropertyIsPublic(prop))
return false;
}
else if (field != null)
{
if (!field.IsPublic)
return false;
}
if (prop != null)
{
info.Serializer = serializer.GetTypeSerializer(prop.PropertyType);
info.Setter = (o, v) => prop.SetValue(o, v, null);
info.Getter = (o) => prop.GetValue(o, null);
}
else if (field != null)
{
info.Serializer = serializer.GetTypeSerializer(field.FieldType);
info.Setter = field.SetValue;
info.Getter = field.GetValue;
}
return true;
}
protected override void Initialize()
{
XMLDataPLine.MapData myMap = new XMLDataPLine.MapData();
myMap.mapName = "Battle In The Middle";
myMap.numberOfCastles = 8;
myMap.allies.Add("Humans");
myMap.allies.Add("Elves");
myMap.allies.Add("Dwarves");
string fileName = "data.xml";
XmlWriter writer = XmlWriter.Create(fileName);
IntermediateSerializer.Serialize <XMLDataPLine.MapData>(writer, myMap, fileName);
writer.Close();
base.Initialize();
}
public void OptionalElements()
{
object result;
var filePath = Paths.Xml("07_OptionalElements.xml");
using (var reader = XmlReader.Create(filePath))
result = IntermediateSerializer.Deserialize <object>(reader, filePath);
Assert.NotNull(result);
Assert.IsAssignableFrom <OptionalElements>(result);
var optional = (OptionalElements)result;
Assert.AreEqual(null, optional.a);
Assert.AreEqual(null, optional.b);
Assert.AreEqual(string.Empty, optional.c);
}
public static T Deserialize <T>(string filename)
{
T data;
if (!filename.EndsWith(".xml"))
{
filename += ".xml";
}
using (FileStream stream = new FileStream(filename, FileMode.Open))
{
using (XmlReader reader = XmlReader.Create(stream))
{
data = IntermediateSerializer.Deserialize <T>(reader, null);
}
}
return(data);
}
public void CollectionItemName()
{
object result;
var filePath = Paths.Xml("10_CollectionItemName.xml");
using (var reader = XmlReader.Create(filePath))
result = IntermediateSerializer.Deserialize <object>(reader, filePath);
Assert.NotNull(result);
Assert.IsAssignableFrom <CollectionItemName>(result);
var collections = (CollectionItemName)result;
Assert.NotNull(collections.StringArray);
Assert.AreEqual(2, collections.StringArray.Length);
Assert.AreEqual("Hello", collections.StringArray[0]);
Assert.AreEqual("World", collections.StringArray[1]);
}
public void Dictionaries()
{
object result;
var filePath = Paths.Xml("11_Dictionaries.xml");
using (var reader = XmlReader.Create(filePath))
result = IntermediateSerializer.Deserialize <object>(reader, filePath);
Assert.NotNull(result);
Assert.IsAssignableFrom <Dictionaries>(result);
var dictionaries = (Dictionaries)result;
Assert.NotNull(dictionaries.TestDictionary);
Assert.AreEqual(2, dictionaries.TestDictionary.Count);
Assert.AreEqual(true, dictionaries.TestDictionary[23]);
Assert.AreEqual(false, dictionaries.TestDictionary[42]);
}
public void ExternalReferences()
{
object result;
var filePath = Paths.Xml("17_ExternalReferences.xml");
using (var reader = XmlReader.Create(filePath))
result = IntermediateSerializer.Deserialize <object>(reader, filePath);
Assert.NotNull(result);
Assert.IsAssignableFrom <ExternalReferences>(result);
var externalReferences = (ExternalReferences)result;
Assert.NotNull(externalReferences.Texture);
Assert.IsTrue(externalReferences.Texture.Filename.EndsWith(@"\Xml\grass.tga"));
Assert.NotNull(externalReferences.Shader);
Assert.IsTrue(externalReferences.Shader.Filename.EndsWith(@"\Xml\foliage.fx"));
}
public virtual void saveGame(GameData data)
{
SaveData saveData;
XmlWriter writer;
XmlWriterSettings settings;
saveData = new SaveData();
saveData.playerLevel = data.player.level;
saveData.playerXP = data.player.XP;
saveData.weaponMods = data.player.myWeapon.mods;
saveData.mods = data.mods._content;
saveData.firstModValue = data.mods.firstMod.value;
saveData.missionLevels = new byte[4];
saveData.missionTKinds = new byte[4];
saveData.missionTCounts = new byte[4];
saveData.missionZones = new byte[4];
saveData.missionAreas = new byte[4];
saveData.missionStates = new bool[4];
saveData.missionKinds = new byte[4][];
for (int i = 0; i < 4; i++)
{
saveData.missionLevels[i] = data.missions[i].level;
saveData.missionTKinds[i] = data.missions[i].target;
saveData.missionTCounts[i] = data.missions[i].tarCount;
//saveData.missionKinds[i] = data.missions[i].Kinds;
saveData.missionZones[i] = data.missions[i].Zone;
saveData.missionAreas[i] = data.missions[i].Area;
saveData.missionStates[i] = data.missions[i].active;
saveData.missionKinds[i] = data.missions[i].Kinds;
}
string filename = "doNotTouchThis.Never";
settings = new XmlWriterSettings();
settings.Indent = true;
writer = XmlWriter.Create(filename, settings);
using (writer)
{
IntermediateSerializer.Serialize(writer, saveData, null);
}
}
public override object Process(string inputClass, ContentProcessorContext context)
{
var inputType = findTypeForClass(inputClass, context);
var xmlSettings = new XmlWriterSettings();
xmlSettings.Indent = true;
var obj = Activator.CreateInstance(inputType);
var outputString = new StringBuilder();
using (var xmlWriter = XmlWriter.Create(outputString, xmlSettings))
IntermediateSerializer.Serialize(xmlWriter, obj, null);
context.Logger.LogMessage("\n------- BEGIN XML TEMPLATE -------\n{0}\n------- END XML TEMPLATE -------\n", outputString);
throw new Exception("------ DISREGARD THIS EXCEPTION. IT IS THROWN ONLY SO THE XNB DOESNT GET WRITTEN TO THE PROJECT FILE");
}
protected internal override void Initialize(IntermediateSerializer serializer)
{
var properties = TargetType.GetAllProperties();
foreach (var prop in properties)
{
ElementInfo info;
if (GetElementInfo(serializer, prop, out info))
_elements.Add(info.Name, info);
}
var fields = TargetType.GetAllFields();
foreach (var field in fields)
{
ElementInfo info;
if (GetElementInfo(serializer, field, out info))
_elements.Add(info.Name, info);
}
}
/* The Load<T>() function loads an object from a certain file path. */
public static T Load <T>(string path)
{
/* A generically typed variable is declared, which will be returned at the end.
* Using a new FileStream with Open as the FileMode, and an XmlReader that uses the stream,
* the object is deserialized from the XML file in the path. */
T data;
using (FileStream stream = new FileStream(path, FileMode.Open))
{
using (XmlReader reader = XmlReader.Create(stream))
{
data = IntermediateSerializer.Deserialize <T>(reader, null);
}
}
/* The object is then returned. */
return(data);
}
internal CollectionHelper(IntermediateSerializer serializer, Type type)
{
this.targetType = type;
Type type2 = CollectionUtils.CollectionElementType(type, false);
if (type2 == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.NotACollectionType, new object[]
{
type
}));
}
this.contentSerializer = serializer.GetTypeSerializer(type2);
Type type3 = typeof(ICollection<>).MakeGenericType(new Type[]
{
type2
});
this.countPropertyGetter = ReflectionEmitUtils.GenerateGetter(type3.GetProperty("Count"));
this.addToCollection = ReflectionEmitUtils.GenerateAddToCollection(type3, type2);
}
public static void SerializeMap <T>(string filename, T data)
{
XmlWriterSettings settings = new XmlWriterSettings
{
Indent = true
};
if (!filename.EndsWith(".xml"))
{
filename += ".xml";
}
//filename = "/TestGame/Content/maps/" + filename;
filename = "Content/maps/" + filename;
//filename = Directory.GetParent(Directory.GetCurrentDirectory()).Parent.Parent.FullName + filename;
using (XmlWriter writer = XmlWriter.Create(filename, settings))
{
IntermediateSerializer.Serialize <T>(writer, data, null);
}
}
public static T LoadXML <T>(String filename)
{
Object data = null;
if (!filename.EndsWith(".xml", true, System.Globalization.CultureInfo.CurrentCulture))
{
filename = filename + ".xml";
}
XmlReaderSettings xmlSettings = new XmlReaderSettings();
xmlSettings.IgnoreComments = true;
using (XmlReader xmlReader = XmlReader.Create(filename, xmlSettings))
{
data = IntermediateSerializer.Deserialize <T>(xmlReader, filename);
}
return((T)data);
}
public void Namespaces()
{
object result;
var filePath = Paths.Xml("14_Namespaces.xml");
using (var reader = XmlReader.Create(filePath))
result = IntermediateSerializer.Deserialize <object>(reader, filePath);
Assert.NotNull(result);
Assert.IsAssignableFrom <NamespaceClass>(result);
var namespaceClass = (NamespaceClass)result;
Assert.IsAssignableFrom <NamespaceHelper>(namespaceClass.A);
Assert.AreEqual(true, ((NamespaceHelper)namespaceClass.A).Value);
Assert.IsAssignableFrom <Vector2>(namespaceClass.B);
Assert.AreEqual(Vector2.Zero, namespaceClass.B);
Assert.IsAssignableFrom <SpriteSortMode>(namespaceClass.C);
Assert.AreEqual(SpriteSortMode.Immediate, namespaceClass.C);
}
private void SaveCurve_Click(object sender, RoutedEventArgs e)
{
CurveTreeLeaf leaf = ((FrameworkElement)sender).DataContext as CurveTreeLeaf;
if (leaf == null)
{
return;
}
// Get the actual curve to save.
Curve curve = leaf.Curve.Curve;
if (curve == null)
{
return;
}
// Configure save file dialog box
Microsoft.Win32.SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog();
dlg.FileName = leaf.Curve.Name; // Default file name
dlg.DefaultExt = ".xml"; // Default file extension
dlg.Filter = "Xml files (.xml)|*.xml"; // Filter files by extension
// Show save file dialog box
Nullable <bool> result = dlg.ShowDialog();
// Process save file dialog box results
if (result != true)
{
return;
}
// Write!
using (var streamOut = new FileStream(dlg.FileName, FileMode.Create))
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.IndentChars = " ";
XmlWriter writer = XmlWriter.Create(streamOut, settings);
IntermediateSerializer.Serialize <Curve>(writer, curve, dlg.FileName);
writer.Close();
}
}
/// <summary>
/// Loads all factories found at the specified path.
/// </summary>
/// <param name="path">The path.</param>
public static void Load(string path)
{
SavePath = path;
SavePath += '/';
SavePath = SavePath.Replace('\\', '/');
SavePath = SavePath.Substring(0, SavePath.LastIndexOf('/') + 1);
Clear();
foreach (var file in Directory.GetFiles(path, "*.xml", SearchOption.AllDirectories))
{
using (var reader = new XmlTextReader(file))
{
try
{
var attributePools = IntermediateSerializer.Deserialize <object>(reader, null) as AttributePool[];
if (attributePools != null)
{
foreach (var attributePool in attributePools)
{
// Adjust paths.
foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(attributePool, new Attribute[] { new EditorAttribute(typeof(TextureAssetEditor), typeof(UITypeEditor)) }))
{
var value = property.GetValue(attributePool) as string;
if (!string.IsNullOrWhiteSpace(value))
{
property.SetValue(attributePool, value.Replace('\\', '/'));
}
}
Add(attributePool);
AttributePoolFilenames.Add(attributePool, file);
}
}
}
catch (InvalidContentException ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
}
}
}
private void loadAnimationToolStripMenuItem_Click(object sender, EventArgs e)
{
if (loadAnimationDialog.ShowDialog() == DialogResult.OK)
{
Animation loadedAnimation;
using (XmlReader xmlRead = XmlReader.Create(loadAnimationDialog.FileName))
{
loadedAnimation = IntermediateSerializer.Deserialize <Animation>(xmlRead, null);
}
if (animationBox.Enabled == false)
{
EnableAnimationEditingControls();
InitiateAnimationList();
}
AddAnimation(loadedAnimation);
currentAnimation = animations[animationBox.SelectedIndex];
ReadAnimationInfo();
UpdateAnimation();
}
}
public override List <byte[]> Import(string filename, ContentImporterContext context)
{
List <byte[]> imageData = new List <byte[]>();
List <string> imageFilenames;
context.AddDependency(Path.Combine(Environment.CurrentDirectory, filename));
using (XmlReader reader = XmlReader.Create(filename))
{
imageFilenames = IntermediateSerializer.Deserialize <List <string> >(reader, null);
}
foreach (string imageFilename in imageFilenames)
{
byte[] imageBytes = File.ReadAllBytes(imageFilename);
imageData.Add(imageBytes);
context.AddDependency(Path.Combine(Environment.CurrentDirectory, imageFilename));
}
return(imageData);
}
public void TheBasics()
{
object result;
var filePath = Paths.Xml("01_TheBasics.xml");
using (var reader = XmlReader.Create(filePath))
result = IntermediateSerializer.Deserialize <object>(reader, filePath);
Assert.NotNull(result);
Assert.IsAssignableFrom <TheBasics>(result);
var theBasics = (TheBasics)result;
Assert.AreEqual(1, theBasics.PublicField);
Assert.AreEqual(0, theBasics.InternalField);
Assert.AreEqual("Hello World", theBasics.GetSetProperty);
Assert.NotNull(theBasics.Nested);
Assert.AreEqual("Shawn", theBasics.Nested.Name);
Assert.AreEqual(true, theBasics.Nested.IsEnglish);
}
public virtual void loadGame(GameData data)
{
string filename = "doNotTouchThis.Never";
XmlReaderSettings settings = new XmlReaderSettings();
SaveData saveData;
XmlReader reader;
reader = XmlReader.Create(filename, settings);
using (reader)
{
saveData = IntermediateSerializer.Deserialize <SaveData>(reader, null);
}
byte[][] kinds = saveData.missionKinds;
data.loadData(saveData.playerLevel, saveData.playerXP, saveData.weaponMods,
saveData.mods, saveData.missionLevels, saveData.missionTKinds, saveData.missionTCounts,
saveData.missionZones, saveData.missionAreas, saveData.missionStates, saveData.missionKinds, saveData.firstModValue);
}
public void SharedResources()
{
object result;
var filePath = Paths.Xml("16_SharedResources.xml");
using (var reader = XmlReader.Create(filePath))
result = IntermediateSerializer.Deserialize <object>(reader, filePath);
Assert.NotNull(result);
Assert.IsAssignableFrom <SharedResources>(result);
var sharedResources = (SharedResources)result;
Assert.NotNull(sharedResources.Head);
Assert.AreEqual(1, sharedResources.Head.Value);
Assert.NotNull(sharedResources.Head.Next);
Assert.AreEqual(2, sharedResources.Head.Next.Value);
Assert.NotNull(sharedResources.Head.Next.Next);
Assert.AreEqual(3, sharedResources.Head.Next.Next.Value);
Assert.AreSame(sharedResources.Head, sharedResources.Head.Next.Next.Next);
}
static void Main(string[] args)
{
Console.Write("Type in the number of which level to build (none for test level): ");
int input;
LevelData ExampleData;
string exportPath = "../../../NDE/NDEContent/levels/";
try
{
input = Convert.ToInt32(Console.ReadLine());
}
catch (OverflowException)
{
input = 0;
}
catch (FormatException)
{
input = 0;
}
if (input > 0)
{
exportPath += "level" + input + ".xml";
LevelCreator newLevel = new LevelCreator();
ExampleData = newLevel.buildLevel(Convert.ToInt32(input));
}
else
{
exportPath += "dummyLevel.xml";
ExampleData = dummyLevel();
}
// Set up XML writer
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
// Export directly to NDEContent directory for immediate deserialization
using (XmlWriter writer = XmlWriter.Create(exportPath, settings))
IntermediateSerializer.Serialize(writer, ExampleData, null);
}
private void LoadSpriteMap()
{
if (loadMapDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
CurrentSpriteMapFileLocation = loadMapDialog.FileName;
Dictionary <string, Sprite> loadedSpriteMap;
using (XmlReader xmlRead = XmlReader.Create(CurrentSpriteMapFileLocation))
{
loadedSpriteMap = IntermediateSerializer.Deserialize <Dictionary <string, Sprite> >(xmlRead, null);
}
sprites = new BindingList <Sprite>();
foreach (KeyValuePair <string, Sprite> sprite in loadedSpriteMap)
{
sprites.Add(sprite.Value);
}
spriteList.DataSource = sprites;
}
}
public void FlattenContent()
{
object result;
var filePath = Paths.Xml("15_FlattenContent.xml");
using (var reader = XmlReader.Create(filePath))
result = IntermediateSerializer.Deserialize <object>(reader, filePath);
Assert.NotNull(result);
Assert.IsAssignableFrom <FlattenContent>(result);
var flattenContent = (FlattenContent)result;
Assert.IsAssignableFrom <NestedClass>(flattenContent.Nested);
Assert.NotNull(flattenContent.Nested);
Assert.AreEqual("Shawn", flattenContent.Nested.Name);
Assert.AreEqual(true, flattenContent.Nested.IsEnglish);
Assert.NotNull(flattenContent.Collection);
Assert.AreEqual(2, flattenContent.Collection.Length);
Assert.AreEqual("Hello", flattenContent.Collection[0]);
Assert.AreEqual("World", flattenContent.Collection[1]);
}
public string GetContentAsXml()
{
if (xmlContent == null)
{
if (base.Count == 0)
{
xmlContent = string.Empty;
}
else
{
StringBuilder output = new StringBuilder();
using (XmlWriter writer = XmlWriter.Create(output))
{
IntermediateSerializer.Serialize <OpaqueDataDictionary>(writer, this, null);
}
this.xmlContent = output.ToString();
}
}
return(this.xmlContent);
}
public void UnitEditorMapMenuSave()
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
string path = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
//string path = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
path += @"\SavedUnitData\";
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
using (XmlWriter writer = XmlWriter.Create(
path + Save_Name + ".xml", settings))
{
IntermediateSerializer.Serialize(writer, _unitData, null);
}
LastSavedUnitData = new Map_Unit_Data(_unitData);
}
public static T DeserializeMap <T>(string filename)
{
T data;
if (!filename.EndsWith(".xml"))
{
filename += ".xml";
}
//filename = "/TestGame/Content/maps/" + filename;
filename = "Content/maps/" + filename;
//filename = Directory.GetParent(Directory.GetCurrentDirectory()).Parent.Parent.FullName + filename;
Debug.WriteLine(filename);
using (FileStream stream = new FileStream(filename, FileMode.Open))
{
using (XmlReader reader = XmlReader.Create(stream))
{
data = IntermediateSerializer.Deserialize <T>(reader, null);
}
}
return(data);
}
private static string Serialize <T>(string filePath, T value)
{
string referenceRelocationPath = filePath;
// Note: Can't use StringBuilder here because it is always UTF-16,
// while our test XML files use a UTF-8 encoding.
var memoryStream = new MemoryStream();
var xmlWriterSettings = new XmlWriterSettings
{
Encoding = Encoding.UTF8,
Indent = true
};
using (var writer = XmlWriter.Create(memoryStream, xmlWriterSettings))
IntermediateSerializer.Serialize(writer, value, referenceRelocationPath);
memoryStream.Position = 0;
var actualXml = new StreamReader(memoryStream).ReadToEnd();
return(actualXml);
}
/* When the Export World button is pressed start a routine to serialize the world */
private void ExportWorld_Click(object sender, EventArgs e)
{
ObjectList.TopNode.Tag = game.root;
/* If the world have a name */
if (this.textBox1.Text != "")
{
/* Start a dialog to choose where to save the exported file */
SaveFileDialog saveFile = new SaveFileDialog();
saveFile.Title = "Save World";
saveFile.DefaultExt = ".xml";
saveFile.Filter = "XML Files (*.xml)|*.xml|" +
"All Files (*.*)|*.*";
saveFile.AddExtension = true;
saveFile.OverwritePrompt = true;
saveFile.FileName = this.textBox1.Text;
if (saveFile.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
/* Transfrom the services of the created World Objects to Factories */
this.game.root = (WorldObject)this.ObjectList.TopNode.Tag;
Cursor = Cursors.WaitCursor;
ServicesToFactories(this.game.root);
/* Start the serialization */
XmlWriterSettings xmlSettings = new XmlWriterSettings();
xmlSettings.Indent = true;
using (XmlWriter xmlWriter = XmlWriter.Create(saveFile.FileName, xmlSettings))
{
IntermediateSerializer.Serialize(xmlWriter, this.game.root, null);
}
}
Cursor = Cursors.Arrow;
this.game.Exit();
this.Close();
}
/* In case that the world name is not yet defined ask for one */
else
{
//InsertName insertName = new InsertName();
//insertName.ShowDialog();
}
}
/// <summary>
/// Save the current state of this GameLevel as an XML file.
/// </summary>
/// <param name="path">File path to save this GameLevel.</param>
public void saveLevel(String path)
{
// XML writer settings for serialization
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
// GameLevelData to hold state data
GameLevelData data = new GameLevelData();
// Save GameTiles
data.NumRows = _tileRows;
data.NumCols = _tileCols;
data.Tiles = new GameTileData[_tileRows * _tileCols];
for (int row = 0; row < _tileRows; row++)
{
for (int col = 0; col < _tileCols; col++)
{
data.Tiles[row * _tileCols + col] = _tiles[row, col].save();
}
}
// Save GameObjects
data.GameObjs = new GameObjectData[_gameObjs.Count];
int i = 0;
foreach (KeyValuePair <String, GameObject> entry in _gameObjs)
{
data.GameObjs[i] = entry.Value.save();
i++;
}
// Write XML file
using (XmlWriter writer = XmlWriter.Create(path + ".xml", settings))
IntermediateSerializer.Serialize(writer, data, null);
// Print success message to console
Console.WriteLine("Current level saved to: " + path);
}
private Dictionary <string, Sprite> LoadSpriteMapFromFile()
{
if (loadSpriteMapDialog.ShowDialog() == DialogResult.OK)
{
Dictionary <string, Sprite> loadedSpriteMap;
using (XmlReader xmlRead = XmlReader.Create(loadSpriteMapDialog.FileName))
{
loadedSpriteMap = IntermediateSerializer.Deserialize <Dictionary <string, Sprite> >(xmlRead, null);
}
spriteMap = new BindingList <Sprite>();
foreach (KeyValuePair <string, Sprite> sprite in loadedSpriteMap)
{
spriteMap.Add(sprite.Value);
}
spriteMapListBox.DataSource = spriteMap;
spriteMapListBox.DisplayMember = "Name";
spriteMapListBox.ValueMember = "Bounds";
//enable spriteMap-required controls
addSpriteToFrameListButton.Enabled = true;
addSpriteToFrameSpritesButton.Enabled = true;
replaceSpriteButton.Enabled = true;
if (currentAnimation == null)
{
frames = new BindingList <Frame>();
frameListBox.DataSource = frames;
frameListBox.DisplayMember = "Name";
InitiateAnimationList();
}
EnableAnimationEditingControls();
return(loadedSpriteMap);
}
return(null);
}
/// <summary>
/// Loads all factories found at the specified path.
/// </summary>
/// <param name="path">The path.</param>
public static void Load(string path)
{
Clear();
foreach (var file in Directory.GetFiles(path, "*.xml", SearchOption.AllDirectories))
{
using (var reader = new XmlTextReader(file))
{
try
{
var factories = IntermediateSerializer.Deserialize <object>(reader, null) as IFactory[];
if (factories != null)
{
foreach (var factory in factories)
{
// Adjust paths.
foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(factory, new Attribute[] { new EditorAttribute(typeof(TextureAssetEditor), typeof(UITypeEditor)) }))
{
var value = property.GetValue(factory) as string;
if (!string.IsNullOrWhiteSpace(value))
{
property.SetValue(factory, value.Replace('\\', '/'));
}
}
Add(factory);
FactoryFilenames.Add(factory, file);
}
}
}
catch (InvalidContentException ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
}
}
}
/// <summary>Retrieves and caches any nested type serializers and allows reflection over the target data type.</summary>
/// <param name="serializer">The content serializer.</param>
protected internal virtual void Initialize(IntermediateSerializer serializer)
{
}
protected internal override void ScanChildren(IntermediateSerializer serializer, ChildCallback callback, object value)
{
throw new NotImplementedException();
}
protected internal override void Initialize(IntermediateSerializer serializer)
{
// If we have a base type then we need to deserialize it first.
if (TargetType.BaseType != null)
_baseSerializer = serializer.GetTypeSerializer(TargetType.BaseType);
// Cache all our serializable properties.
var properties = TargetType.GetProperties(_bindingFlags);
foreach (var prop in properties)
{
ElementInfo info;
if (GetElementInfo(serializer, prop, out info))
_elements.Add(info);
}
// Cache all our serializable fields.
var fields = TargetType.GetFields(_bindingFlags);
foreach (var field in fields)
{
ElementInfo info;
if (GetElementInfo(serializer, field, out info))
_elements.Add(info);
}
}
private bool GetElementInfo(IntermediateSerializer serializer, MemberInfo member, out ElementInfo info)
{
info = new ElementInfo();
// Are we ignoring this property?
if (ReflectionHelpers.GetCustomAttribute<ContentSerializerIgnoreAttribute>(member) != null)
return false;
var prop = member as PropertyInfo;
var field = member as FieldInfo;
var attrib = ReflectionHelpers.GetCustomAttribute<ContentSerializerAttribute>(member);
if (attrib != null)
{
// Store the attribute for later use.
info.Attribute = attrib.Clone();
// Default the to member name as the element name.
if (string.IsNullOrEmpty(attrib.ElementName))
info.Attribute.ElementName = member.Name;
}
else
{
// We don't have a serializer attribute, so we can
// only access this member thru a public field/property.
if (prop != null)
{
// If we don't have at least a public getter then this
// property can't be serialized or deserialized in any way.
if (prop.GetGetMethod() == null)
return false;
// If there is a setter, but it's private, then don't include this element
// (although technically we could, as long as we have a serializer with
// CanDeserializeIntoExistingObject=true for this property type)
var setter = prop.GetSetMethod(true);
if (setter != null && !setter.IsPublic)
return false;
// If there is no setter, and we don't have a type serializer
// that can deserialize into an existing object, then we have no way
// for it to be deserialized.
if (setter == null && !serializer.GetTypeSerializer(prop.PropertyType).CanDeserializeIntoExistingObject)
return false;
// Don't serialize or deserialize indexers.
if (prop.GetIndexParameters().Any())
return false;
}
else if (field != null)
{
if (!field.IsPublic)
return false;
}
info.Attribute = new ContentSerializerAttribute();
info.Attribute.ElementName = member.Name;
}
if (prop != null)
{
info.Serializer = serializer.GetTypeSerializer(prop.PropertyType);
if (prop.CanWrite)
info.Setter = (o, v) => prop.SetValue(o, v, null);
info.Getter = o => prop.GetValue(o, null);
}
else if (field != null)
{
info.Serializer = serializer.GetTypeSerializer(field.FieldType);
info.Setter = field.SetValue;
info.Getter = field.GetValue;
}
return true;
}
protected internal override void ScanChildren (IntermediateSerializer serializer, ChildCallback callback, object value)
{
base.ScanChildren (serializer, callback, value);
}
protected internal override void ScanChildren(IntermediateSerializer serializer, ChildCallback callback, object value)
{
if (serializer.AlreadyScanned(value))
return;
// First scan the base type.
if (_baseSerializer != null)
_baseSerializer.ScanChildren(serializer, callback, value);
// Now scan our own elements.
foreach (var info in _elements)
{
var elementValue = info.Getter(value);
callback(info.Serializer, elementValue);
var elementSerializer = info.Serializer;
if (elementValue != null)
elementSerializer = serializer.GetTypeSerializer(elementValue.GetType());
elementSerializer.ScanChildren(serializer, callback, elementValue);
}
}
/// <summary>Examines the children of the specified object, passing each to a callback delegate.</summary>
/// <param name="serializer">The content serializer.</param>
/// <param name="callback">The method to be called for each examined child.</param>
/// <param name="value">The object whose children are being scanned.</param>
protected internal virtual void ScanChildren(IntermediateSerializer serializer, ContentTypeSerializer.ChildCallback callback, object value)
{
}
