Ignore whitespace when reading serialized XML objects.

This was previously effectively being done by XmlDocument in the multiple passes through the XML.
This change tells XmlReader to ignore whitespace.  This also means changing arguments to use XmlReader instead of XmlTextReader (a descendent of XmlReader) directly.
XmlReader.Create() has been the recommend way to create XML readers since .NET 2.0 as per MS SDK and is the only way to specific ignore whitespace settings.

5 files changed, 193 insertions, 205 deletions

diff --git a/OpenSim/Region/CoreModules/World/Serialiser/Tests/SerialiserTests.cs b/OpenSim/Region/CoreModules/World/Serialiser/Tests/SerialiserTests.cs
index 94cd9cd..a5bb1a7 100644
--- a/OpenSim/Region/CoreModules/World/Serialiser/Tests/SerialiserTests.cs
+++ b/OpenSim/Region/CoreModules/World/Serialiser/Tests/SerialiserTests.cs
@@ -624,23 +624,7 @@ namespace OpenSim.Region.CoreModules.World.Serialiser.Tests
             TestHelpers.InMethod();
             TestHelpers.EnableLogging();
 
-            // We need to do this to get rid of whitespace between elements.
-            // TODO: Ultimately OpenSimulator xml parser should be set to ignore this but this means a bit of 
-            // rejigging to replace old new XmlTextReader() with the post .NET 2.0 XmlReader.Create() calls
-            XmlDocument xdoc = new XmlDocument();
-            xdoc.LoadXml(ObjectWithOtherPartsXml);
-
-            StringBuilder sb = new StringBuilder();
-            using (StringWriter sw = new StringWriter(sb))
-            {
-                using (XmlTextWriter xtw = new XmlTextWriter(sw))
-                {
-//                    xtw.Formatting = Formatting.Indented;
-                    xdoc.WriteTo(xtw);
-                }
-            }
-
-            SceneObjectGroup so = SceneObjectSerializer.FromOriginalXmlFormat(sb.ToString());
+            SceneObjectGroup so = SceneObjectSerializer.FromOriginalXmlFormat(ObjectWithOtherPartsXml);
             SceneObjectPart[] parts = so.Parts;
             Assert.AreEqual(3, so.Parts.Length);
 
diff --git a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
index cbb4fe7..3489873 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
@@ -2214,49 +2214,52 @@ namespace OpenSim.Region.Framework.Scenes
 
             try
             {
-                using (XmlTextReader reader = new XmlTextReader(xmlData, XmlNodeType.Element, null))
+                using (XmlTextReader wrappedReader = new XmlTextReader(xmlData, XmlNodeType.Element, null))
                 {
-                    reader.Read();
-                    bool isSingleObject = reader.Name != "CoalescedObject";
-
-                    if (isSingleObject || isAttachment)
+                    using (XmlReader reader = XmlReader.Create(wrappedReader, new XmlReaderSettings() { IgnoreWhitespace = true, ConformanceLevel = ConformanceLevel.Fragment }))
                     {
-                        SceneObjectGroup g = SceneObjectSerializer.FromOriginalXmlFormat(reader);
-                        objlist.Add(g);
-                        veclist.Add(Vector3.Zero);
-                        bbox = g.GetAxisAlignedBoundingBox(out offsetHeight);
-                        return true;
-                    }
-                    else
-                    {                
-                        XmlDocument doc = new XmlDocument();
-                        doc.LoadXml(xmlData);
-                        XmlElement e = (XmlElement)doc.SelectSingleNode("/CoalescedObject");
-                        XmlElement coll = (XmlElement)e;
-                        float bx = Convert.ToSingle(coll.GetAttribute("x"));
-                        float by = Convert.ToSingle(coll.GetAttribute("y"));
-                        float bz = Convert.ToSingle(coll.GetAttribute("z"));
-                        bbox = new Vector3(bx, by, bz);
-                        offsetHeight = 0;
-
-                        XmlNodeList groups = e.SelectNodes("SceneObjectGroup");
-                        foreach (XmlNode n in groups)
+                        reader.Read();
+                        bool isSingleObject = reader.Name != "CoalescedObject";
+
+                        if (isSingleObject || isAttachment)
                         {
-                            SceneObjectGroup g = SceneObjectSerializer.FromOriginalXmlFormat(n.OuterXml);
+                            SceneObjectGroup g = SceneObjectSerializer.FromOriginalXmlFormat(reader);
                             objlist.Add(g);
-
-                            XmlElement el = (XmlElement)n;
-                            string rawX = el.GetAttribute("offsetx");
-                            string rawY = el.GetAttribute("offsety");
-                            string rawZ = el.GetAttribute("offsetz");
-
-                            float x = Convert.ToSingle(rawX);
-                            float y = Convert.ToSingle(rawY);
-                            float z = Convert.ToSingle(rawZ);
-                            veclist.Add(new Vector3(x, y, z));
+                            veclist.Add(Vector3.Zero);
+                            bbox = g.GetAxisAlignedBoundingBox(out offsetHeight);
+                            return true;
                         }
+                        else
+                        {                
+                            XmlDocument doc = new XmlDocument();
+                            doc.LoadXml(xmlData);
+                            XmlElement e = (XmlElement)doc.SelectSingleNode("/CoalescedObject");
+                            XmlElement coll = (XmlElement)e;
+                            float bx = Convert.ToSingle(coll.GetAttribute("x"));
+                            float by = Convert.ToSingle(coll.GetAttribute("y"));
+                            float bz = Convert.ToSingle(coll.GetAttribute("z"));
+                            bbox = new Vector3(bx, by, bz);
+                            offsetHeight = 0;
+
+                            XmlNodeList groups = e.SelectNodes("SceneObjectGroup");
+                            foreach (XmlNode n in groups)
+                            {
+                                SceneObjectGroup g = SceneObjectSerializer.FromOriginalXmlFormat(n.OuterXml);
+                                objlist.Add(g);
+
+                                XmlElement el = (XmlElement)n;
+                                string rawX = el.GetAttribute("offsetx");
+                                string rawY = el.GetAttribute("offsety");
+                                string rawZ = el.GetAttribute("offsetz");
+
+                                float x = Convert.ToSingle(rawX);
+                                float y = Convert.ToSingle(rawY);
+                                float z = Convert.ToSingle(rawZ);
+                                veclist.Add(new Vector3(x, y, z));
+                            }
 
-                        return false;
+                            return false;
+                        }
                     }
                 }
             }
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index c95d207..e37bbd8 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -902,7 +902,7 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        public void LoadScriptState(XmlTextReader reader)
+        public void LoadScriptState(XmlReader reader)
         {
 //            m_log.DebugFormat("[SCENE OBJECT GROUP]: Looking for script state for {0} in {1}", Name);
 
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
index 31fc26e..05e3ee9 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
@@ -2044,7 +2044,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <param name="xmlReader"></param>
         /// <returns></returns>
-        public static SceneObjectPart FromXml(XmlTextReader xmlReader)
+        public static SceneObjectPart FromXml(XmlReader xmlReader)
         {
             SceneObjectPart part = SceneObjectSerializer.Xml2ToSOP(xmlReader);
 
diff --git a/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs b/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
index 8f99dc6..3899b99 100644
--- a/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
+++ b/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
@@ -59,8 +59,9 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
         /// <returns>The scene object deserialized.  Null on failure.</returns>
         public static SceneObjectGroup FromOriginalXmlFormat(string xmlData)
         {
-            using (XmlTextReader reader = new XmlTextReader(xmlData, XmlNodeType.Element, null))
-                return FromOriginalXmlFormat(reader);
+            using (XmlTextReader wrappedReader = new XmlTextReader(xmlData, XmlNodeType.Element, null))
+                using (XmlReader reader = XmlReader.Create(wrappedReader, new XmlReaderSettings() { IgnoreWhitespace = true, ConformanceLevel = ConformanceLevel.Fragment }))
+                    return FromOriginalXmlFormat(reader);
         }
 
         /// <summary>
@@ -68,7 +69,7 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
         /// </summary>
         /// <param name="xmlData"></param>
         /// <returns>The scene object deserialized.  Null on failure.</returns>
-        public static SceneObjectGroup FromOriginalXmlFormat(XmlTextReader reader)
+        public static SceneObjectGroup FromOriginalXmlFormat(XmlReader reader)
         {
             //m_log.DebugFormat("[SOG]: Starting deserialization of SOG");
             //int time = System.Environment.TickCount;
@@ -370,14 +371,14 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
 
         #region manual serialization
 
-        private static Dictionary<string, Action<SceneObjectPart, XmlTextReader>> m_SOPXmlProcessors
-            = new Dictionary<string, Action<SceneObjectPart, XmlTextReader>>();
+        private static Dictionary<string, Action<SceneObjectPart, XmlReader>> m_SOPXmlProcessors
+            = new Dictionary<string, Action<SceneObjectPart, XmlReader>>();
 
-        private static Dictionary<string, Action<TaskInventoryItem, XmlTextReader>> m_TaskInventoryXmlProcessors
-            = new Dictionary<string, Action<TaskInventoryItem, XmlTextReader>>();
+        private static Dictionary<string, Action<TaskInventoryItem, XmlReader>> m_TaskInventoryXmlProcessors
+            = new Dictionary<string, Action<TaskInventoryItem, XmlReader>>();
 
-        private static Dictionary<string, Action<PrimitiveBaseShape, XmlTextReader>> m_ShapeXmlProcessors
-            = new Dictionary<string, Action<PrimitiveBaseShape, XmlTextReader>>();
+        private static Dictionary<string, Action<PrimitiveBaseShape, XmlReader>> m_ShapeXmlProcessors
+            = new Dictionary<string, Action<PrimitiveBaseShape, XmlReader>>();
 
         static SceneObjectSerializer()
         {
@@ -533,112 +534,112 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
         }
 
         #region SOPXmlProcessors
-        private static void ProcessAllowedDrop(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessAllowedDrop(SceneObjectPart obj, XmlReader reader)
         {
             obj.AllowedDrop = Util.ReadBoolean(reader);
         }
 
-        private static void ProcessCreatorID(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessCreatorID(SceneObjectPart obj, XmlReader reader)
         {
             obj.CreatorID = Util.ReadUUID(reader, "CreatorID");
         }
 
-        private static void ProcessCreatorData(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessCreatorData(SceneObjectPart obj, XmlReader reader)
         {
             obj.CreatorData = reader.ReadElementContentAsString("CreatorData", String.Empty);
         }
 
-        private static void ProcessFolderID(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessFolderID(SceneObjectPart obj, XmlReader reader)
         {
             obj.FolderID = Util.ReadUUID(reader, "FolderID");
         }
 
-        private static void ProcessInventorySerial(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessInventorySerial(SceneObjectPart obj, XmlReader reader)
         {
             obj.InventorySerial = (uint)reader.ReadElementContentAsInt("InventorySerial", String.Empty);
         }
 
-        private static void ProcessTaskInventory(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessTaskInventory(SceneObjectPart obj, XmlReader reader)
         {
             obj.TaskInventory = ReadTaskInventory(reader, "TaskInventory");
         }
 
-        private static void ProcessUUID(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessUUID(SceneObjectPart obj, XmlReader reader)
         {
             obj.UUID = Util.ReadUUID(reader, "UUID");
         }
 
-        private static void ProcessLocalId(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessLocalId(SceneObjectPart obj, XmlReader reader)
         {
             obj.LocalId = (uint)reader.ReadElementContentAsLong("LocalId", String.Empty);
         }
 
-        private static void ProcessName(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessName(SceneObjectPart obj, XmlReader reader)
         {
             obj.Name = reader.ReadElementString("Name");
         }
 
-        private static void ProcessMaterial(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessMaterial(SceneObjectPart obj, XmlReader reader)
         {
             obj.Material = (byte)reader.ReadElementContentAsInt("Material", String.Empty);
         }
 
-        private static void ProcessPassTouches(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessPassTouches(SceneObjectPart obj, XmlReader reader)
         {
             obj.PassTouches = Util.ReadBoolean(reader);
         }
 
-        private static void ProcessPassCollisions(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessPassCollisions(SceneObjectPart obj, XmlReader reader)
         {
             obj.PassCollisions = Util.ReadBoolean(reader);
         }
 
-        private static void ProcessRegionHandle(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessRegionHandle(SceneObjectPart obj, XmlReader reader)
         {
             obj.RegionHandle = (ulong)reader.ReadElementContentAsLong("RegionHandle", String.Empty);
         }
 
-        private static void ProcessScriptAccessPin(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessScriptAccessPin(SceneObjectPart obj, XmlReader reader)
         {
             obj.ScriptAccessPin = reader.ReadElementContentAsInt("ScriptAccessPin", String.Empty);
         }
 
-        private static void ProcessGroupPosition(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessGroupPosition(SceneObjectPart obj, XmlReader reader)
         {
             obj.GroupPosition = Util.ReadVector(reader, "GroupPosition");
         }
 
-        private static void ProcessOffsetPosition(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessOffsetPosition(SceneObjectPart obj, XmlReader reader)
         {
             obj.OffsetPosition = Util.ReadVector(reader, "OffsetPosition"); ;
         }
 
-        private static void ProcessRotationOffset(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessRotationOffset(SceneObjectPart obj, XmlReader reader)
         {
             obj.RotationOffset = Util.ReadQuaternion(reader, "RotationOffset");
         }
 
-        private static void ProcessVelocity(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessVelocity(SceneObjectPart obj, XmlReader reader)
         {
             obj.Velocity = Util.ReadVector(reader, "Velocity");
         }
 
-        private static void ProcessAngularVelocity(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessAngularVelocity(SceneObjectPart obj, XmlReader reader)
         {
             obj.AngularVelocity = Util.ReadVector(reader, "AngularVelocity");
         }
 
-        private static void ProcessAcceleration(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessAcceleration(SceneObjectPart obj, XmlReader reader)
         {
             obj.Acceleration = Util.ReadVector(reader, "Acceleration");
         }
 
-        private static void ProcessDescription(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessDescription(SceneObjectPart obj, XmlReader reader)
         {
             obj.Description = reader.ReadElementString("Description");
         }
 
-        private static void ProcessColor(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessColor(SceneObjectPart obj, XmlReader reader)
         {
             reader.ReadStartElement("Color");
             if (reader.Name == "R")
@@ -652,57 +653,57 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             }
         }
 
-        private static void ProcessText(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessText(SceneObjectPart obj, XmlReader reader)
         {
             obj.Text = reader.ReadElementString("Text", String.Empty);
         }
 
-        private static void ProcessSitName(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessSitName(SceneObjectPart obj, XmlReader reader)
         {
             obj.SitName = reader.ReadElementString("SitName", String.Empty);
         }
 
-        private static void ProcessTouchName(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessTouchName(SceneObjectPart obj, XmlReader reader)
         {
             obj.TouchName = reader.ReadElementString("TouchName", String.Empty);
         }
 
-        private static void ProcessLinkNum(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessLinkNum(SceneObjectPart obj, XmlReader reader)
         {
             obj.LinkNum = reader.ReadElementContentAsInt("LinkNum", String.Empty);
         }
 
-        private static void ProcessClickAction(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessClickAction(SceneObjectPart obj, XmlReader reader)
         {
             obj.ClickAction = (byte)reader.ReadElementContentAsInt("ClickAction", String.Empty);
         }
 
-        private static void ProcessPhysicsShapeType(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessPhysicsShapeType(SceneObjectPart obj, XmlReader reader)
         {
             obj.PhysicsShapeType = (byte)reader.ReadElementContentAsInt("PhysicsShapeType", String.Empty);
         }
 
-        private static void ProcessDensity(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessDensity(SceneObjectPart obj, XmlReader reader)
         {
             obj.Density = reader.ReadElementContentAsFloat("Density", String.Empty);
         }
 
-        private static void ProcessFriction(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessFriction(SceneObjectPart obj, XmlReader reader)
         {
             obj.Friction = reader.ReadElementContentAsFloat("Friction", String.Empty);
         }
 
-        private static void ProcessBounce(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessBounce(SceneObjectPart obj, XmlReader reader)
         {
             obj.Restitution = reader.ReadElementContentAsFloat("Bounce", String.Empty);
         }
 
-        private static void ProcessGravityModifier(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessGravityModifier(SceneObjectPart obj, XmlReader reader)
         {
             obj.GravityModifier = reader.ReadElementContentAsFloat("GravityModifier", String.Empty);
         }
 
-        private static void ProcessShape(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessShape(SceneObjectPart obj, XmlReader reader)
         {
             List<string> errorNodeNames;
             obj.Shape = ReadShape(reader, "Shape", out errorNodeNames);
@@ -715,163 +716,163 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             }
         }
 
-        private static void ProcessScale(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessScale(SceneObjectPart obj, XmlReader reader)
         {
             obj.Scale = Util.ReadVector(reader, "Scale");
         }
 
-        private static void ProcessSitTargetOrientation(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessSitTargetOrientation(SceneObjectPart obj, XmlReader reader)
         {
             obj.SitTargetOrientation = Util.ReadQuaternion(reader, "SitTargetOrientation");
         }
 
-        private static void ProcessSitTargetPosition(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessSitTargetPosition(SceneObjectPart obj, XmlReader reader)
         {
             obj.SitTargetPosition = Util.ReadVector(reader, "SitTargetPosition");
         }
 
-        private static void ProcessSitTargetPositionLL(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessSitTargetPositionLL(SceneObjectPart obj, XmlReader reader)
         {
             obj.SitTargetPositionLL = Util.ReadVector(reader, "SitTargetPositionLL");
         }
 
-        private static void ProcessSitTargetOrientationLL(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessSitTargetOrientationLL(SceneObjectPart obj, XmlReader reader)
         {
             obj.SitTargetOrientationLL = Util.ReadQuaternion(reader, "SitTargetOrientationLL");
         }
 
-        private static void ProcessParentID(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessParentID(SceneObjectPart obj, XmlReader reader)
         {
             string str = reader.ReadElementContentAsString("ParentID", String.Empty);
             obj.ParentID = Convert.ToUInt32(str);
         }
 
-        private static void ProcessCreationDate(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessCreationDate(SceneObjectPart obj, XmlReader reader)
         {
             obj.CreationDate = reader.ReadElementContentAsInt("CreationDate", String.Empty);
         }
 
-        private static void ProcessCategory(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessCategory(SceneObjectPart obj, XmlReader reader)
         {
             obj.Category = (uint)reader.ReadElementContentAsInt("Category", String.Empty);
         }
 
-        private static void ProcessSalePrice(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessSalePrice(SceneObjectPart obj, XmlReader reader)
         {
             obj.SalePrice = reader.ReadElementContentAsInt("SalePrice", String.Empty);
         }
 
-        private static void ProcessObjectSaleType(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessObjectSaleType(SceneObjectPart obj, XmlReader reader)
         {
             obj.ObjectSaleType = (byte)reader.ReadElementContentAsInt("ObjectSaleType", String.Empty);
         }
 
-        private static void ProcessOwnershipCost(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessOwnershipCost(SceneObjectPart obj, XmlReader reader)
         {
             obj.OwnershipCost = reader.ReadElementContentAsInt("OwnershipCost", String.Empty);
         }
 
-        private static void ProcessGroupID(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessGroupID(SceneObjectPart obj, XmlReader reader)
         {
             obj.GroupID = Util.ReadUUID(reader, "GroupID");
         }
 
-        private static void ProcessOwnerID(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessOwnerID(SceneObjectPart obj, XmlReader reader)
         {
             obj.OwnerID = Util.ReadUUID(reader, "OwnerID");
         }
 
-        private static void ProcessLastOwnerID(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessLastOwnerID(SceneObjectPart obj, XmlReader reader)
         {
             obj.LastOwnerID = Util.ReadUUID(reader, "LastOwnerID");
         }
 
-        private static void ProcessBaseMask(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessBaseMask(SceneObjectPart obj, XmlReader reader)
         {
             obj.BaseMask = (uint)reader.ReadElementContentAsInt("BaseMask", String.Empty);
         }
 
-        private static void ProcessOwnerMask(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessOwnerMask(SceneObjectPart obj, XmlReader reader)
         {
             obj.OwnerMask = (uint)reader.ReadElementContentAsInt("OwnerMask", String.Empty);
         }
 
-        private static void ProcessGroupMask(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessGroupMask(SceneObjectPart obj, XmlReader reader)
         {
             obj.GroupMask = (uint)reader.ReadElementContentAsInt("GroupMask", String.Empty);
         }
 
-        private static void ProcessEveryoneMask(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessEveryoneMask(SceneObjectPart obj, XmlReader reader)
         {
             obj.EveryoneMask = (uint)reader.ReadElementContentAsInt("EveryoneMask", String.Empty);
         }
 
-        private static void ProcessNextOwnerMask(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessNextOwnerMask(SceneObjectPart obj, XmlReader reader)
         {
             obj.NextOwnerMask = (uint)reader.ReadElementContentAsInt("NextOwnerMask", String.Empty);
         }
 
-        private static void ProcessFlags(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessFlags(SceneObjectPart obj, XmlReader reader)
         {
             obj.Flags = Util.ReadEnum<PrimFlags>(reader, "Flags");
         }
 
-        private static void ProcessCollisionSound(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessCollisionSound(SceneObjectPart obj, XmlReader reader)
         {
             obj.CollisionSound = Util.ReadUUID(reader, "CollisionSound");
         }
 
-        private static void ProcessCollisionSoundVolume(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessCollisionSoundVolume(SceneObjectPart obj, XmlReader reader)
         {
             obj.CollisionSoundVolume = reader.ReadElementContentAsFloat("CollisionSoundVolume", String.Empty);
         }
 
-        private static void ProcessMediaUrl(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessMediaUrl(SceneObjectPart obj, XmlReader reader)
         {
             obj.MediaUrl = reader.ReadElementContentAsString("MediaUrl", String.Empty);
         }
 
-        private static void ProcessAttachedPos(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessAttachedPos(SceneObjectPart obj, XmlReader reader)
         {
             obj.AttachedPos = Util.ReadVector(reader, "AttachedPos");
         }
 
-        private static void ProcessDynAttrs(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessDynAttrs(SceneObjectPart obj, XmlReader reader)
         {
             obj.DynAttrs.ReadXml(reader);
         }
 
-        private static void ProcessTextureAnimation(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessTextureAnimation(SceneObjectPart obj, XmlReader reader)
         {
             obj.TextureAnimation = Convert.FromBase64String(reader.ReadElementContentAsString("TextureAnimation", String.Empty));
         }
 
-        private static void ProcessParticleSystem(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessParticleSystem(SceneObjectPart obj, XmlReader reader)
         {
             obj.ParticleSystem = Convert.FromBase64String(reader.ReadElementContentAsString("ParticleSystem", String.Empty));
         }
 
-        private static void ProcessPayPrice0(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessPayPrice0(SceneObjectPart obj, XmlReader reader)
         {
             obj.PayPrice[0] = (int)reader.ReadElementContentAsInt("PayPrice0", String.Empty);
         }
 
-        private static void ProcessPayPrice1(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessPayPrice1(SceneObjectPart obj, XmlReader reader)
         {
             obj.PayPrice[1] = (int)reader.ReadElementContentAsInt("PayPrice1", String.Empty);
         }
 
-        private static void ProcessPayPrice2(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessPayPrice2(SceneObjectPart obj, XmlReader reader)
         {
             obj.PayPrice[2] = (int)reader.ReadElementContentAsInt("PayPrice2", String.Empty);
         }
 
-        private static void ProcessPayPrice3(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessPayPrice3(SceneObjectPart obj, XmlReader reader)
         {
             obj.PayPrice[3] = (int)reader.ReadElementContentAsInt("PayPrice3", String.Empty);
         }
 
-        private static void ProcessPayPrice4(SceneObjectPart obj, XmlTextReader reader)
+        private static void ProcessPayPrice4(SceneObjectPart obj, XmlReader reader)
         {
             obj.PayPrice[4] = (int)reader.ReadElementContentAsInt("PayPrice4", String.Empty);
         }
@@ -879,122 +880,122 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
         #endregion
 
         #region TaskInventoryXmlProcessors
-        private static void ProcessTIAssetID(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTIAssetID(TaskInventoryItem item, XmlReader reader)
         {
             item.AssetID = Util.ReadUUID(reader, "AssetID");
         }
 
-        private static void ProcessTIBasePermissions(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTIBasePermissions(TaskInventoryItem item, XmlReader reader)
         {
             item.BasePermissions = (uint)reader.ReadElementContentAsInt("BasePermissions", String.Empty);
         }
 
-        private static void ProcessTICreationDate(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTICreationDate(TaskInventoryItem item, XmlReader reader)
         {
             item.CreationDate = (uint)reader.ReadElementContentAsInt("CreationDate", String.Empty);
         }
 
-        private static void ProcessTICreatorID(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTICreatorID(TaskInventoryItem item, XmlReader reader)
         {
             item.CreatorID = Util.ReadUUID(reader, "CreatorID");
         }
 
-        private static void ProcessTICreatorData(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTICreatorData(TaskInventoryItem item, XmlReader reader)
         {
             item.CreatorData = reader.ReadElementContentAsString("CreatorData", String.Empty);
         }
 
-        private static void ProcessTIDescription(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTIDescription(TaskInventoryItem item, XmlReader reader)
         {
             item.Description = reader.ReadElementContentAsString("Description", String.Empty);
         }
 
-        private static void ProcessTIEveryonePermissions(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTIEveryonePermissions(TaskInventoryItem item, XmlReader reader)
         {
             item.EveryonePermissions = (uint)reader.ReadElementContentAsInt("EveryonePermissions", String.Empty);
         }
 
-        private static void ProcessTIFlags(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTIFlags(TaskInventoryItem item, XmlReader reader)
         {
             item.Flags = (uint)reader.ReadElementContentAsInt("Flags", String.Empty);
         }
 
-        private static void ProcessTIGroupID(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTIGroupID(TaskInventoryItem item, XmlReader reader)
         {
             item.GroupID = Util.ReadUUID(reader, "GroupID");
         }
 
-        private static void ProcessTIGroupPermissions(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTIGroupPermissions(TaskInventoryItem item, XmlReader reader)
         {
             item.GroupPermissions = (uint)reader.ReadElementContentAsInt("GroupPermissions", String.Empty);
         }
 
-        private static void ProcessTIInvType(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTIInvType(TaskInventoryItem item, XmlReader reader)
         {
             item.InvType = reader.ReadElementContentAsInt("InvType", String.Empty);
         }
 
-        private static void ProcessTIItemID(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTIItemID(TaskInventoryItem item, XmlReader reader)
         {
             item.ItemID = Util.ReadUUID(reader, "ItemID");
         }
 
-        private static void ProcessTIOldItemID(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTIOldItemID(TaskInventoryItem item, XmlReader reader)
         {
             item.OldItemID = Util.ReadUUID(reader, "OldItemID");
         }
 
-        private static void ProcessTILastOwnerID(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTILastOwnerID(TaskInventoryItem item, XmlReader reader)
         {
             item.LastOwnerID = Util.ReadUUID(reader, "LastOwnerID");
         }
 
-        private static void ProcessTIName(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTIName(TaskInventoryItem item, XmlReader reader)
         {
             item.Name = reader.ReadElementContentAsString("Name", String.Empty);
         }
 
-        private static void ProcessTINextPermissions(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTINextPermissions(TaskInventoryItem item, XmlReader reader)
         {
             item.NextPermissions = (uint)reader.ReadElementContentAsInt("NextPermissions", String.Empty);
         }
 
-        private static void ProcessTIOwnerID(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTIOwnerID(TaskInventoryItem item, XmlReader reader)
         {
             item.OwnerID = Util.ReadUUID(reader, "OwnerID");
         }
 
-        private static void ProcessTICurrentPermissions(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTICurrentPermissions(TaskInventoryItem item, XmlReader reader)
         {
             item.CurrentPermissions = (uint)reader.ReadElementContentAsInt("CurrentPermissions", String.Empty);
         }
 
-        private static void ProcessTIParentID(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTIParentID(TaskInventoryItem item, XmlReader reader)
         {
             item.ParentID = Util.ReadUUID(reader, "ParentID");
         }
 
-        private static void ProcessTIParentPartID(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTIParentPartID(TaskInventoryItem item, XmlReader reader)
         {
             item.ParentPartID = Util.ReadUUID(reader, "ParentPartID");
         }
 
-        private static void ProcessTIPermsGranter(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTIPermsGranter(TaskInventoryItem item, XmlReader reader)
         {
             item.PermsGranter = Util.ReadUUID(reader, "PermsGranter");
         }
 
-        private static void ProcessTIPermsMask(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTIPermsMask(TaskInventoryItem item, XmlReader reader)
         {
             item.PermsMask = reader.ReadElementContentAsInt("PermsMask", String.Empty);
         }
 
-        private static void ProcessTIType(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTIType(TaskInventoryItem item, XmlReader reader)
         {
             item.Type = reader.ReadElementContentAsInt("Type", String.Empty);
         }
 
-        private static void ProcessTIOwnerChanged(TaskInventoryItem item, XmlTextReader reader)
+        private static void ProcessTIOwnerChanged(TaskInventoryItem item, XmlReader reader)
         {
             item.OwnerChanged = Util.ReadBoolean(reader);
         }
@@ -1002,243 +1003,243 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
         #endregion
 
         #region ShapeXmlProcessors
-        private static void ProcessShpProfileCurve(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpProfileCurve(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.ProfileCurve = (byte)reader.ReadElementContentAsInt("ProfileCurve", String.Empty);
         }
 
-        private static void ProcessShpTextureEntry(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpTextureEntry(PrimitiveBaseShape shp, XmlReader reader)
         {
             byte[] teData = Convert.FromBase64String(reader.ReadElementString("TextureEntry"));
             shp.Textures = new Primitive.TextureEntry(teData, 0, teData.Length);
         }
 
-        private static void ProcessShpExtraParams(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpExtraParams(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.ExtraParams = Convert.FromBase64String(reader.ReadElementString("ExtraParams"));
         }
 
-        private static void ProcessShpPathBegin(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpPathBegin(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.PathBegin = (ushort)reader.ReadElementContentAsInt("PathBegin", String.Empty);
         }
 
-        private static void ProcessShpPathCurve(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpPathCurve(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.PathCurve = (byte)reader.ReadElementContentAsInt("PathCurve", String.Empty);
         }
 
-        private static void ProcessShpPathEnd(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpPathEnd(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.PathEnd = (ushort)reader.ReadElementContentAsInt("PathEnd", String.Empty);
         }
 
-        private static void ProcessShpPathRadiusOffset(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpPathRadiusOffset(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.PathRadiusOffset = (sbyte)reader.ReadElementContentAsInt("PathRadiusOffset", String.Empty);
         }
 
-        private static void ProcessShpPathRevolutions(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpPathRevolutions(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.PathRevolutions = (byte)reader.ReadElementContentAsInt("PathRevolutions", String.Empty);
         }
 
-        private static void ProcessShpPathScaleX(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpPathScaleX(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.PathScaleX = (byte)reader.ReadElementContentAsInt("PathScaleX", String.Empty);
         }
 
-        private static void ProcessShpPathScaleY(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpPathScaleY(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.PathScaleY = (byte)reader.ReadElementContentAsInt("PathScaleY", String.Empty);
         }
 
-        private static void ProcessShpPathShearX(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpPathShearX(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.PathShearX = (byte)reader.ReadElementContentAsInt("PathShearX", String.Empty);
         }
 
-        private static void ProcessShpPathShearY(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpPathShearY(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.PathShearY = (byte)reader.ReadElementContentAsInt("PathShearY", String.Empty);
         }
 
-        private static void ProcessShpPathSkew(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpPathSkew(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.PathSkew = (sbyte)reader.ReadElementContentAsInt("PathSkew", String.Empty);
         }
 
-        private static void ProcessShpPathTaperX(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpPathTaperX(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.PathTaperX = (sbyte)reader.ReadElementContentAsInt("PathTaperX", String.Empty);
         }
 
-        private static void ProcessShpPathTaperY(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpPathTaperY(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.PathTaperY = (sbyte)reader.ReadElementContentAsInt("PathTaperY", String.Empty);
         }
 
-        private static void ProcessShpPathTwist(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpPathTwist(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.PathTwist = (sbyte)reader.ReadElementContentAsInt("PathTwist", String.Empty);
         }
 
-        private static void ProcessShpPathTwistBegin(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpPathTwistBegin(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.PathTwistBegin = (sbyte)reader.ReadElementContentAsInt("PathTwistBegin", String.Empty);
         }
 
-        private static void ProcessShpPCode(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpPCode(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.PCode = (byte)reader.ReadElementContentAsInt("PCode", String.Empty);
         }
 
-        private static void ProcessShpProfileBegin(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpProfileBegin(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.ProfileBegin = (ushort)reader.ReadElementContentAsInt("ProfileBegin", String.Empty);
         }
 
-        private static void ProcessShpProfileEnd(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpProfileEnd(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.ProfileEnd = (ushort)reader.ReadElementContentAsInt("ProfileEnd", String.Empty);
         }
 
-        private static void ProcessShpProfileHollow(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpProfileHollow(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.ProfileHollow = (ushort)reader.ReadElementContentAsInt("ProfileHollow", String.Empty);
         }
 
-        private static void ProcessShpScale(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpScale(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.Scale = Util.ReadVector(reader, "Scale");
         }
 
-        private static void ProcessShpState(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpState(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.State = (byte)reader.ReadElementContentAsInt("State", String.Empty);
         }
 
-        private static void ProcessShpLastAttach(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpLastAttach(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.LastAttachPoint = (byte)reader.ReadElementContentAsInt("LastAttachPoint", String.Empty);
         }
 
-        private static void ProcessShpProfileShape(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpProfileShape(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.ProfileShape = Util.ReadEnum<ProfileShape>(reader, "ProfileShape");
         }
 
-        private static void ProcessShpHollowShape(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpHollowShape(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.HollowShape = Util.ReadEnum<HollowShape>(reader, "HollowShape");
         }
         
-        private static void ProcessShpSculptTexture(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpSculptTexture(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.SculptTexture = Util.ReadUUID(reader, "SculptTexture");
         }
 
-        private static void ProcessShpSculptType(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpSculptType(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.SculptType = (byte)reader.ReadElementContentAsInt("SculptType", String.Empty);
         }
 
-        private static void ProcessShpFlexiSoftness(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpFlexiSoftness(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.FlexiSoftness = reader.ReadElementContentAsInt("FlexiSoftness", String.Empty);
         }
 
-        private static void ProcessShpFlexiTension(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpFlexiTension(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.FlexiTension = reader.ReadElementContentAsFloat("FlexiTension", String.Empty);
         }
 
-        private static void ProcessShpFlexiDrag(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpFlexiDrag(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.FlexiDrag = reader.ReadElementContentAsFloat("FlexiDrag", String.Empty);
         }
 
-        private static void ProcessShpFlexiGravity(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpFlexiGravity(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.FlexiGravity = reader.ReadElementContentAsFloat("FlexiGravity", String.Empty);
         }
 
-        private static void ProcessShpFlexiWind(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpFlexiWind(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.FlexiWind = reader.ReadElementContentAsFloat("FlexiWind", String.Empty);
         }
 
-        private static void ProcessShpFlexiForceX(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpFlexiForceX(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.FlexiForceX = reader.ReadElementContentAsFloat("FlexiForceX", String.Empty);
         }
 
-        private static void ProcessShpFlexiForceY(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpFlexiForceY(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.FlexiForceY = reader.ReadElementContentAsFloat("FlexiForceY", String.Empty);
         }
 
-        private static void ProcessShpFlexiForceZ(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpFlexiForceZ(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.FlexiForceZ = reader.ReadElementContentAsFloat("FlexiForceZ", String.Empty);
         }
 
-        private static void ProcessShpLightColorR(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpLightColorR(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.LightColorR = reader.ReadElementContentAsFloat("LightColorR", String.Empty);
         }
 
-        private static void ProcessShpLightColorG(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpLightColorG(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.LightColorG = reader.ReadElementContentAsFloat("LightColorG", String.Empty);
         }
 
-        private static void ProcessShpLightColorB(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpLightColorB(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.LightColorB = reader.ReadElementContentAsFloat("LightColorB", String.Empty);
         }
 
-        private static void ProcessShpLightColorA(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpLightColorA(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.LightColorA = reader.ReadElementContentAsFloat("LightColorA", String.Empty);
         }
 
-        private static void ProcessShpLightRadius(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpLightRadius(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.LightRadius = reader.ReadElementContentAsFloat("LightRadius", String.Empty);
         }
 
-        private static void ProcessShpLightCutoff(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpLightCutoff(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.LightCutoff = reader.ReadElementContentAsFloat("LightCutoff", String.Empty);
         }
 
-        private static void ProcessShpLightFalloff(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpLightFalloff(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.LightFalloff = reader.ReadElementContentAsFloat("LightFalloff", String.Empty);
         }
 
-        private static void ProcessShpLightIntensity(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpLightIntensity(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.LightIntensity = reader.ReadElementContentAsFloat("LightIntensity", String.Empty);
         }
 
-        private static void ProcessShpFlexiEntry(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpFlexiEntry(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.FlexiEntry = Util.ReadBoolean(reader);
         }
 
-        private static void ProcessShpLightEntry(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpLightEntry(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.LightEntry = Util.ReadBoolean(reader);
         }
 
-        private static void ProcessShpSculptEntry(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpSculptEntry(PrimitiveBaseShape shp, XmlReader reader)
         {
             shp.SculptEntry = Util.ReadBoolean(reader);
         }
 
-        private static void ProcessShpMedia(PrimitiveBaseShape shp, XmlTextReader reader)
+        private static void ProcessShpMedia(PrimitiveBaseShape shp, XmlReader reader)
         {
             string value = reader.ReadElementContentAsString("Media", String.Empty);
             shp.Media = PrimitiveBaseShape.MediaList.FromXml(value);
@@ -1590,7 +1591,7 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             }
         }
 
-        public static SceneObjectPart Xml2ToSOP(XmlTextReader reader)
+        public static SceneObjectPart Xml2ToSOP(XmlReader reader)
         {
             SceneObjectPart obj = new SceneObjectPart();
 
@@ -1611,7 +1612,7 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             return obj;
         }
 
-        public static TaskInventoryDictionary ReadTaskInventory(XmlTextReader reader, string name)
+        public static TaskInventoryDictionary ReadTaskInventory(XmlReader reader, string name)
         {
             TaskInventoryDictionary tinv = new TaskInventoryDictionary();
 
@@ -1652,7 +1653,7 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
         /// <param name="name">The name of the xml element containing the shape</param>
         /// <param name="errors">a list containing the failing node names.  If no failures then null.</param>
         /// <returns>The shape parsed</returns>
-        public static PrimitiveBaseShape ReadShape(XmlTextReader reader, string name, out List<string> errorNodeNames)
+        public static PrimitiveBaseShape ReadShape(XmlReader reader, string name, out List<string> errorNodeNames)
         {
             List<string> internalErrorNodeNames = null;