System.Xml.XmlReader.ReadContentAsString()

Here are the examples of the csharp api System.Xml.XmlReader.ReadContentAsString() taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

59 Examples 7

19 Source : V2Loader.cs
with MIT License
from Abdesol

static XshdRule ParseRule(XmlReader reader)
		{
			XshdRule rule = new XshdRule();
			SetPosition(rule, reader);
			rule.ColorReference = ParseColorReference(reader);
			if (!reader.IsEmptyElement) {
				reader.Read();
				if (reader.NodeType == XmlNodeType.Text) {
					rule.Regex = reader.ReadContentreplacedtring();
					rule.RegexType = XshdRegexType.IgnorePatternWhitespace;
				}
			}
			return rule;
		}

19 Source : XmlHelper.cs
with Mozilla Public License 2.0
from agebullhu

public static string ReadXmlText(XmlReader xr)
        {
            try
            {
                xr.Read() ;
                return xr.ReadContentreplacedtring().Trim() ;
            }
            catch
            {
                return null ;
            }
        }

19 Source : TokenDecrypt.cs
with Mozilla Public License 2.0
from agebullhu

public static string Decrypt(string xml)
        {
            var sr = new StringReader(xml) ;
            var xr = XmlReader.Create(sr) ;
            xr.ReadToDescendant("trust:RequestSecurityTokenResponse") ;
            xr.ReadToFollowing("trust:RequestedSecurityToken") ;
            xr.ReadToDescendant("xenc:EncryptedData") ;
            xr.ReadToDescendant("KeyInfo") ;
            xr.ReadToDescendant("e:EncryptedKey") ;
            xr.ReadToDescendant("KeyInfo") ;
            xr.ReadToDescendant("o:SecurityTokenReference") ;
            xr.ReadToDescendant("X509Data") ;
            xr.ReadToDescendant("X509IssuerSerial") ;
            xr.ReadToDescendant("X509IssuerName") ;
            xr.Read() ;
            var cername = xr.ReadContentreplacedtring().Trim() ;
            xr.ReadToNextSibling("X509SerialNumber") ;
            xr.Read() ;
            var cersn = xr.ReadContentreplacedtring().Trim() ;
            xr.Close() ;
            var doc = new XmlDoreplacedent() ;
            doc.InnerXml = xml ;
            var xm = new XmlNamespaceManager(doc.NameTable) ;
            xm.AddNamespace("trust" , "http://docs.oasis-open.org/ws-sx/ws-trust/200512") ;
            xm.AddNamespace("wsu" , "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd") ;
            xm.AddNamespace("xenc" , "http://www.w3.org/2001/04/xmlenc#") ;
            xm.AddNamespace("e" , "http://www.w3.org/2001/04/xmlenc#") ;
            xm.AddNamespace("e" , "http://www.w3.org/2001/04/xmlenc#") ;
            xm.AddNamespace("" , "http://www.w3.org/2000/09/xmldsig#") ;
            var old = doc.SelectSingleNode("//trust:RequestSecurityTokenResponse" , xm) ;
            if(old == null)
            {
                return null ;
            }
            old = old.SelectSingleNode("//trust:RequestedSecurityToken" , xm) ;
            if(old == null)
            {
                return null ;
            }
            old = old.SelectSingleNode("//xenc:EncryptedData" , xm) ;
            if(old != null)
            {
                foreach(XmlNode n in old.ChildNodes)
                {
                    if(n.LocalName != "KeyInfo")
                    {
                        continue ;
                    }
                    old = n ;
                    break ;
                }
            }
            if(old == null)
            {
                return null ;
            }
            old = old.SelectSingleNode("//e:EncryptedKey" , xm) ;
            if(old == null)
            {
                return null ;
            }
            foreach(XmlNode n in old.ChildNodes)
            {
                if(n.LocalName != "KeyInfo")
                {
                    continue ;
                }
                old = n ;
                break ;
            }
            old.InnerXml = "<KeyName>rsaKey</KeyName>" ;
            DecryptDoreplacedent(doc , cername , cersn , "rsaKey") ;
            return doc.InnerXml ;
        }

19 Source : XmlLayoutReader.cs
with GNU General Public License v3.0
from AndreiFedarets

private Menu ReadMenu(XmlReader reader, IContainer container)
        {
            //Move to <Menu> element
            MoveToElement(reader, MenuElementName);

            string id = string.Empty;
            Type controlHandlerType = typeof(MenuControlHandlerDefault);

            //Read <Menu> attributes
            while (reader.MoveToNextAttribute())
            {
                switch (reader.Name)
                {
                    case IdAttributeName:
                        id = reader.ReadContentreplacedtring();
                        break;
                    case TypeAttributeName:
                        string type = reader.ReadContentreplacedtring();
                        controlHandlerType = Type.GetType(type);
                        break;
                }
            }

            Menu control = new Menu(id);

            IMenuControlHandler controlHandler = new MenuControlHandlerLazy(controlHandlerType, container);
            control.AttachHandler(controlHandler);

            //Read <Menu> element content
            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.EndElement && string.Equals(MenuElementName, reader.Name))
                {
                    break;
                }
                if (reader.NodeType != XmlNodeType.Element)
                {
                    continue;
                }
                switch (reader.Name)
                {
                    case MenuItemElementName:
                        MenuItem menuItem = ReadMenuItem(reader, container);
                        control.Add(menuItem);
                        break;
                }
            }

            return control;
        }

19 Source : RegistryRoot.cs
with GNU General Public License v3.0
from AndreiFedarets

private static RegistryKey ReadRegistryKey(XmlReader reader)
        {
            Microsoft.Win32.RegistryView registryView = Microsoft.Win32.RegistryView.Default;
            RemoveType removeType = RemoveType.No;
            string name = string.Empty;
            List<RegistryKey> keys = new List<RegistryKey>();
            List<RegistryValue> values = new List<RegistryValue>();

            while (reader.MoveToNextAttribute())
            {
                switch (reader.Name)
                {
                    case KeyNameAttributeName:
                        name = reader.ReadContentreplacedtring();
                        break;
                    case KeyRegistryViewAttributeName:
                        registryView = reader.ReadContentAsEnum<Microsoft.Win32.RegistryView>();
                        break;
                    case KeyRemoveTypeAttributeName:
                        removeType = reader.ReadContentAsEnum<RemoveType>();
                        break;
                }
            }

            reader.MoveToElement();

            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.EndElement &&
                    string.Equals(KeyElementName, reader.Name))
                {
                    break;
                }
                if (reader.NodeType != XmlNodeType.Element)
                {
                    continue;
                }
                switch (reader.Name)
                {
                    case KeyElementName:
                        RegistryKey registryKey = ReadRegistryKey(reader);
                        keys.Add(registryKey);
                        break;
                    case ValueElementName:
                        RegistryValue registryValue = ReadRegistryValue(reader);
                        values.Add(registryValue);
                        break;
                }
            }
            RegistryKey registry = new RegistryKey(name, removeType, keys, values, registryView);
            return registry;
        }

19 Source : SolutionXmlReader.cs
with GNU General Public License v3.0
from AndreiFedarets

private PackageFolder ReadPackageFolder(XmlReader reader)
        {
            MoveToElement(reader, PackageElementName);

            string debug = string.Empty;
            string release = string.Empty;

            //Read Element attributes
            while (reader.MoveToNextAttribute())
            {
                switch (reader.Name)
                {
                    case DebugAttributeName:
                        debug = reader.ReadContentreplacedtring();
                        break;
                    case ReleaseAttributeName:
                        release = reader.ReadContentreplacedtring();
                        break;
                }
            }

            //Move back to Element element
            reader.MoveToElement();

            PackageFolder packageFolder = new PackageFolder(debug, release);
            return packageFolder;
        }

19 Source : XmlLayoutReader.cs
with GNU General Public License v3.0
from AndreiFedarets

private MenuItem ReadMenuItem(XmlReader reader, IContainer container)
        {
            //Move to <MenuItem> element
            MoveToElement(reader, MenuItemElementName);

            string id = string.Empty;
            Type controlHandlerType = typeof(MenuControlHandlerDefault);

            //Read <MenuItem> attributes
            while (reader.MoveToNextAttribute())
            {
                switch (reader.Name)
                {
                    case IdAttributeName:
                        id = reader.ReadContentreplacedtring();
                        break;
                    case TypeAttributeName:
                        string type = reader.ReadContentreplacedtring();
                        controlHandlerType = Type.GetType(type);
                        break;
                }
            }

            MenuItem control = new MenuItem(id);
            IMenuControlHandler controlHandler = new MenuControlHandlerLazy(controlHandlerType, container);
            control.AttachHandler(controlHandler);

            //Read <MenuItem> element content
            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.EndElement && string.Equals(MenuItemElementName, reader.Name))
                {
                    break;
                }
                if (reader.NodeType != XmlNodeType.Element)
                {
                    continue;
                }
                switch (reader.Name)
                {
                    case MenuItemElementName:
                        MenuItem menuItem = ReadMenuItem(reader, container);
                        control.Add(menuItem);
                        break;
                }
            }   

            return control;
        }

19 Source : XmlLayoutReader.cs
with GNU General Public License v3.0
from AndreiFedarets

private ViewModelAttachment ReadViewModelAttachment(XmlReader reader, IViewModel targetViewModel)
        {
            //Move to <ViewModel> element
            MoveToElement(reader, ViewModelElementName);

            string id = string.Empty;
            string typeName = string.Empty;
            ViewModelMode mode = ViewModelMode.Multiple;
            ViewModelActivation activation = ViewModelActivation.OnStartup;
            int order = 0;
            string viewType = string.Empty;

            //Read <ViewModel> attributes
            while (reader.MoveToNextAttribute())
            {
                switch (reader.Name)
                {
                    case IdAttributeName:
                        id = reader.ReadContentreplacedtring();
                        break;
                    case TypeAttributeName:
                        typeName = reader.ReadContentreplacedtring();
                        break;
                    case ViewTypeAttributeName:
                        viewType = reader.ReadContentreplacedtring();
                        break;
                    case ModeAttributeName:
                        mode = reader.ReadContentAsEnum<ViewModelMode>();
                        break;
                    case ActivationAttributeName:
                        activation = reader.ReadContentAsEnum<ViewModelActivation>();
                        break;
                    case OrderAttributeName:
                        order = reader.ReadContentAsInt();
                        break;
                }
            }

            IViewModelFactory viewModelFactory = CreateViewModelFactory(targetViewModel, typeName, mode);

            return new ViewModelAttachment(id, activation, order, viewType, viewModelFactory);
        }

19 Source : XmlExtensionReader.cs
with GNU General Public License v3.0
from AndreiFedarets

private AttributeDefinition ReadAttribute(XmlReader reader)
        {
            //Move to <Attribute> element
            MoveToElement(reader, AttributeElementName);
            string name = string.Empty;
            string value = string.Empty;
            string type = string.Empty;

            //Read Attachment attributes
            while (reader.MoveToNextAttribute())
            {
                switch (reader.Name)
                {
                    case AttributeNameAttributeName:
                        name = reader.ReadContentreplacedtring();
                        break;
                    case AttributeValueAttributeName:
                        value = reader.ReadContentreplacedtring();
                        break;
                    case AttributeTypeAttributeName:
                        type = reader.ReadContentreplacedtring();
                        break;
                }
            }

            AttributeDefinition definition = new AttributeDefinition(name, value, type);
            return definition;
        }

19 Source : XmlExtensionReader.cs
with GNU General Public License v3.0
from AndreiFedarets

private PrerequisiteDefinition ReadPrerequisite(XmlReader reader, string baseDirectory)
        {
            //Move to <Prerequisite> element
            MoveToElement(reader, PrerequisiteElementName);

            //Prepare Prerequisite properties
            string entryPoint = string.Empty;

            //Read Prerequisite attributes
            while (reader.MoveToNextAttribute())
            {
                switch (reader.Name)
                {
                    case EntryPointAttributeName:
                        entryPoint = reader.ReadContentreplacedtring();
                        break;
                }
            }

            //Move back to <Export> element
            reader.MoveToElement();

            PrerequisiteDefinition definition = new PrerequisiteDefinition(baseDirectory, entryPoint);
            return definition;
        }

19 Source : XmlExtensionReader.cs
with GNU General Public License v3.0
from AndreiFedarets

private ExportDefinition ReadExport(XmlReader reader, string baseDirectory)
        {
            //Move to <Export> element
            MoveToElement(reader, ExportElementName);

            //Prepare Export properties
            string application = string.Empty;
            string entryPoint = string.Empty;
            string entryPoint32 = string.Empty;
            string entryPoint64 = string.Empty;
            LoadBehavior loadBehavior = LoadBehavior.OnDemand;

            //Read Export attributes
            while (reader.MoveToNextAttribute())
            {
                switch (reader.Name)
                {
                    case ApplicationAttributeName:
                        application = reader.ReadContentreplacedtring();
                        break;
                    case EntryPointAttributeName:
                        entryPoint = reader.ReadContentreplacedtring();
                        break;
                    case EntryPoint32AttributeName:
                        entryPoint32 = reader.ReadContentreplacedtring();
                        break;
                    case EntryPoint64AttributeName:
                        entryPoint64 = reader.ReadContentreplacedtring();
                        break;
                    case LoadBehaviorAttributeName:
                        loadBehavior = reader.ReadContentAsEnum<LoadBehavior>();
                        break;
                }
            }

            //Move back to <Export> element
            reader.MoveToElement();

            ExportDefinition definition = new ExportDefinition(application, baseDirectory, entryPoint, entryPoint32, entryPoint64, loadBehavior);
            return definition;
        }

19 Source : RegistryRoot.cs
with GNU General Public License v3.0
from AndreiFedarets

private static RegistryValue ReadRegistryValue(XmlReader reader)
        {
            string name = string.Empty;
            Microsoft.Win32.RegistryValueKind type = Microsoft.Win32.RegistryValueKind.String;
            string value = string.Empty;

            while (reader.MoveToNextAttribute())
            {
                switch (reader.Name)
                {
                    case ValueNameAttributeName:
                        name = reader.ReadContentreplacedtring();
                        break;
                    case ValueTypeAttributeName:
                        type = reader.ReadContentAsEnum<Microsoft.Win32.RegistryValueKind>();
                        break;
                    case ValueValueAttributeName:
                        value = reader.ReadContentreplacedtring();
                        break;
                }
            }
            reader.MoveToElement();
            return new RegistryValue(name, type, value);
        }

19 Source : SolutionXmlReader.cs
with GNU General Public License v3.0
from AndreiFedarets

public Solution ReadSolution(SolutionCollection solutions, FileInfo solutionFile)
        {
            BuildFolder buildFolder = null;
            PackageFolder packageFolder = null;
            ExternalsFolder externalsFolder = null;
            List<SolutionDependency> dependencies = new List<SolutionDependency>();
            string name = string.Empty;
            string source = string.Empty;
            using (FileStream stream = solutionFile.OpenRead())
            {
                using (XmlReader reader = XmlReader.Create(stream))
                {
                    MoveToElement(reader, SolutionElementName);

                    //Read Element attributes
                    while (reader.MoveToNextAttribute())
                    {
                        switch (reader.Name)
                        {
                            case SolutionNameAttributeName:
                                name = reader.ReadContentreplacedtring();
                                break;
                        }
                    }

                    //Move back to Element
                    reader.MoveToElement();

                    //Read Element content
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.EndElement &&
                            string.Equals(SolutionElementName, reader.Name))
                        {
                            break;
                        }
                        if (reader.NodeType != XmlNodeType.Element)
                        {
                            continue;
                        }
                        switch (reader.Name)
                        {
                            case BuildElementName:
                                buildFolder = ReadBuildFolder(reader);
                                break;
                            case PackageElementName:
                                packageFolder = ReadPackageFolder(reader);
                                break;
                            case SourceElementName:
                                source = reader.ReadInnerXml();
                                break;
                            case ExternalsElementName:
                                externalsFolder = ReadExternalsFolder(reader);
                                break;
                            case DependenciesElementName:
                                ReadDependencies(reader, dependencies);
                                break;
                        }
                    }
                }
            }
            Solution solution = new Solution(solutions, solutionFile, name, source, buildFolder, packageFolder, externalsFolder, dependencies);
            return solution;
        }

19 Source : SolutionXmlReader.cs
with GNU General Public License v3.0
from AndreiFedarets

private SolutionDependency ReadSolutionDependency(XmlReader reader)
        {
            MoveToElement(reader, SolutionDependencyElementName);

            string name = string.Empty;
            List<FileDependency> dependencies = new List<FileDependency>();

            //Read Element attributes
            while (reader.MoveToNextAttribute())
            {
                switch (reader.Name)
                {
                    case SolutionNameAttributeName:
                        name = reader.ReadContentreplacedtring();
                        break;
                }
            }

            //Move back to Element
            reader.MoveToElement();

            //Read Element content
            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.EndElement &&
                    string.Equals(SolutionDependencyElementName, reader.Name))
                {
                    break;
                }
                if (reader.NodeType != XmlNodeType.Element)
                {
                    continue;
                }
                switch (reader.Name)
                {
                    case FileDependencyElementName:
                        FileDependency fileDependency = ReadFileDependency(reader);
                        dependencies.Add(fileDependency);
                        break;
                }
            }
            SolutionDependency solutionDependency = new SolutionDependency(name, dependencies);
            return solutionDependency;
        }

19 Source : SolutionXmlReader.cs
with GNU General Public License v3.0
from AndreiFedarets

private BuildFolder ReadBuildFolder(XmlReader reader)
        {
            MoveToElement(reader, BuildElementName);

            string debug = string.Empty;
            string release = string.Empty;

            //Read Element attributes
            while (reader.MoveToNextAttribute())
            {
                switch (reader.Name)
                {
                    case DebugAttributeName:
                        debug = reader.ReadContentreplacedtring();
                        break;
                    case ReleaseAttributeName:
                        release = reader.ReadContentreplacedtring();
                        break;
                }
            }

            //Move back to Element element
            reader.MoveToElement();

            BuildFolder buildFolder = new BuildFolder(debug, release);
            return buildFolder;
        }

19 Source : XmlExtensionReader.cs
with GNU General Public License v3.0
from AndreiFedarets

private LocalizationDefinition ReadLocalization(XmlReader reader)
        {
            //Move to <Localization> element
            MoveToElement(reader, LocalizationElementName);

            //Prepare Localization properties
            CultureInfo cultureInfo = CultureInfo.InvariantCulture;
            string name = string.Empty;
            string description = string.Empty;
            string iconUri = null;

            //Read Localization attributes
            while (reader.MoveToNextAttribute())
            {
                switch (reader.Name)
                {
                    case CultureAttributeName:
                        cultureInfo = reader.ReadContentAsCultureInfo();
                        break;
                    case IconUriAttributeName:
                        iconUri = reader.ReadContentreplacedtring();
                        break;
                }
            }

            //Move back to <Localization> element
            reader.MoveToElement();

            //Read <Localization> element content
            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.EndElement &&
                    string.Equals(LocalizationElementName, reader.Name))
                {
                    break;
                }
                if (reader.NodeType != XmlNodeType.Element)
                {
                    continue;
                }
                switch (reader.Name)
                {
                    case NameElementName:
                        name = reader.ReadElementContentreplacedtring();
                        break;
                    case DescriptionElementName:
                        description = reader.ReadElementContentreplacedtring();
                        break;
                }
            }

            LocalizationDefinition definition = new LocalizationDefinition(cultureInfo, name, description, iconUri);
            return definition;
        }

19 Source : SolutionXmlReader.cs
with GNU General Public License v3.0
from AndreiFedarets

private FileDependency ReadFileDependency(XmlReader reader)
        {
            MoveToElement(reader, FileDependencyElementName);

            string name = string.Empty;

            //Read Element attributes
            while (reader.MoveToNextAttribute())
            {
                switch (reader.Name)
                {
                    case SolutionNameAttributeName:
                        name = reader.ReadContentreplacedtring();
                        break;
                }
            }

            //Move back to Element
            reader.MoveToElement();

            FileDependency fileDependency = new FileDependency(name);
            return fileDependency;
        }

19 Source : SolutionXmlReader.cs
with GNU General Public License v3.0
from AndreiFedarets

private ExternalsFolder ReadExternalsFolder(XmlReader reader)
        {
            MoveToElement(reader, ExternalsElementName);

            string debug = string.Empty;
            string release = string.Empty;

            //Read Element attributes
            while (reader.MoveToNextAttribute())
            {
                switch (reader.Name)
                {
                    case DebugAttributeName:
                        debug = reader.ReadContentreplacedtring();
                        break;
                    case ReleaseAttributeName:
                        release = reader.ReadContentreplacedtring();
                        break;
                }
            }

            //Move back to Element
            reader.MoveToElement();

            ExternalsFolder externalsFolder = new ExternalsFolder(debug, release);
            return externalsFolder;
        }

19 Source : V2Loader.cs
with MIT License
from AvaloniaUI

private static XshdRule ParseRule(XmlReader reader)
        {
            var rule = new XshdRule();
            SetPosition(rule, reader);
            rule.ColorReference = ParseColorReference(reader);
            if (!reader.IsEmptyElement)
            {
                reader.Read();
                if (reader.NodeType == XmlNodeType.Text)
                {
                    rule.Regex = reader.ReadContentreplacedtring();
                    rule.RegexType = XshdRegexType.IgnorePatternWhitespace;
                }
            }
            return rule;
        }

19 Source : TimeSpan2.cs
with MIT License
from dahall

void IXmlSerializable.ReadXml(XmlReader reader) => core = XmlConvert.ToTimeSpan(reader?.ReadContentreplacedtring());

19 Source : V2Loader.cs
with MIT License
from Dirkster99

static XshdRule ParseRule(XmlReader reader)
		{
			XshdRule rule = new XshdRule();
			SetPosition(rule, reader);
			rule.ColorReference = ParseColorReference(reader);
			if (!reader.IsEmptyElement)
			{
				reader.Read();
				if (reader.NodeType == XmlNodeType.Text)
				{
					rule.Regex = reader.ReadContentreplacedtring();
					rule.RegexType = XshdRegexType.IgnorePatternWhitespace;
				}
			}
			return rule;
		}

19 Source : basedata.cs
with GNU General Public License v3.0
from elgesl

public override void ReadXml(XmlReader reader)
        {
            reader.MoveToContent();
            reader.Read();

            FromString(new ProtectedString(true, reader.ReadContentreplacedtring()));
        }

19 Source : XmlDeserialize.cs
with GNU Lesser General Public License v3.0
from faib920

private object DeserializeValue(Type type)
        {
            var stype = type.GetNonNullableType();
            var typeCode = Type.GetTypeCode(stype);
            if (typeCode == TypeCode.Object && stype != typeof(TimeSpan))
            {
                return ParseObject(type);
            }

            if (_xmlReader.IsEmptyElement)
            {
                if (_xmlReader.NodeType == XmlNodeType.Element)
                {
                    XmlReaderHelper.ReadAndConsumeMatchingEndElement(_xmlReader);
                }

                return type.GetDefaultValue();
            }

            bool beStartEle;
            if ((beStartEle = (_xmlReader.NodeType == XmlNodeType.Element)))
            {
                XmlReaderHelper.ReadUntilAnyTypesReached(_xmlReader, new[] { XmlNodeType.EndElement, XmlNodeType.Text, XmlNodeType.CDATA });
            }

            var value = _xmlReader.NodeType == XmlNodeType.EndElement ? string.Empty : _xmlReader.ReadContentreplacedtring();
            if (beStartEle)
            {
                XmlReaderHelper.ReadAndConsumeMatchingEndElement(_xmlReader);
            }

            if (type.GetNonNullableType() == typeof(DateTime))
            {
                CheckNullString(value, type);
                return SerializerUtil.ParseDateTime(value, _option.Culture, _option.DateTimeZoneHandling);
            }
            else if (type.GetNonNullableType() == typeof(TimeSpan))
            {
                if (TimeSpan.TryParse(value, out TimeSpan result))
                {
                    return result;
                }
            }

            return value.ToType(type);
        }

19 Source : XmlDeserialize.cs
with GNU Lesser General Public License v3.0
from faib920

private object DeserializeDynamicObject(Type type)
        {
            var dynamicObject = type == typeof(object) ? new ExpandoObject() :
                type.New<IDictionary<string, object>>();

            while (_xmlReader.Read())
            {
                XmlReaderHelper.ReadUntilAnyTypesReached(_xmlReader, new[] { XmlNodeType.Element, XmlNodeType.EndElement, XmlNodeType.Text, XmlNodeType.CDATA });

                if (_xmlReader.NodeType == XmlNodeType.EndElement)
                {
                    _xmlReader.ReadEndElement();
                    break;
                }
                else if (_xmlReader.NodeType == XmlNodeType.Element)
                {
                    var name = _xmlReader.Name;
                    try
                    {
                        var value = Deserialize(typeof(object));
                        dynamicObject.Add(name, value);
                    }
                    catch (replacedumeContentException exp)
                    {
                        dynamicObject.Add(name, exp.Content);
                    }
                }
                else if (_xmlReader.NodeType == XmlNodeType.Text || _xmlReader.NodeType == XmlNodeType.CDATA)
                {
                    throw new replacedumeContentException(_xmlReader.ReadContentreplacedtring());
                }
            }

            return dynamicObject;
        }

19 Source : XmlDeserialize.cs
with GNU Lesser General Public License v3.0
from faib920

private object DeserializeList(Type listType)
        {
            var isReadonly = listType.IsGenericType && listType.GetGenericTypeDefinition() == typeof(IReadOnlyCollection<>);

            CreateListContainer(listType, out Type elementType, out IList container);

            _xmlReader.ReadStartElement();

            while (true)
            {
                XmlReaderHelper.ReadUntilAnyTypesReached(_xmlReader, new[] { XmlNodeType.Element, XmlNodeType.Text, XmlNodeType.CDATA, XmlNodeType.EndElement });

                if (_xmlReader.NodeType == XmlNodeType.EndElement)
                {
                    _xmlReader.ReadEndElement();
                    break;
                }
                else if (_xmlReader.NodeType == XmlNodeType.Element)
                {
                    container.Add(Deserialize(elementType));
                }
                else if (_xmlReader.NodeType == XmlNodeType.Text || _xmlReader.NodeType == XmlNodeType.CDATA)
                {
                    foreach (var str in _xmlReader.ReadContentreplacedtring().Split(',', ';'))
                    {
                        container.Add(str.ToType(elementType));
                    }
                }
            }

            if (listType.IsArray)
            {
                var invoker = ReflectionCache.GetInvoker(MethodCache.ToArray.MakeGenericMethod(elementType));
                return invoker.Invoke(null, container);
            }

            if (isReadonly)
            {
                return listType.GetConstructor(BindingFlags.Instance | BindingFlags.Public, null, new[] { container.GetType() }, null).Invoke(new object[] { container });
            }

            return container;
        }

19 Source : XmlSerializableIPAddress.cs
with MIT License
from jpmikkers

public void ReadXml(XmlReader reader)
        {
            // https://www.codeproject.com/Articles/43237/How-to-Implement-IXmlSerializable-Correctly
            reader.MoveToContent();
            var isEmptyElement = reader.IsEmptyElement;
            reader.ReadStartElement();
            if (!isEmptyElement)
            {
                Address = IPAddress.Parse(reader.ReadContentreplacedtring());
                reader.ReadEndElement();
            }
        }

19 Source : GenericPostureHandle.cs
with GNU General Public License v2.0
from Kinovea

private void ParseConstraint(XmlReader r)
        {
            // A "constraint" represents the valid positions where the handle can go.
            bool isEmpty = r.IsEmptyElement;
            ConstraintType type = ConstraintType.None;
            string optionGroup = "";
            
            if(r.MoveToAttribute("type"))
                type = (ConstraintType) Enum.Parse(typeof(ConstraintType), r.ReadContentreplacedtring());
            
            if(r.MoveToAttribute("optionGroup"))
                optionGroup = r.ReadContentreplacedtring();
            
            r.ReadStartElement();
            
            switch(type)
            {
                case ConstraintType.None:
                    Constraint = null;
                    break;
                case ConstraintType.LineSlide:
                    Constraint = new GenericPostureConstraintLineSlide(r);
                    break;
                case ConstraintType.VerticalSlide:
                    Constraint = new GenericPostureConstraintVerticalSlide();
                    break;
                case ConstraintType.HorizontalSlide:
                    Constraint = new GenericPostureConstraintHorizontalSlide();
                    break;
                case ConstraintType.DistanceToPoint:
                    Constraint = new GenericPostureConstraintDistanceToPoint(r);
                    break;
                case ConstraintType.RotationSteps:
                    Constraint = new GenericPostureConstraintRotationSteps(r);
                    break;
                case ConstraintType.PerpendicularSlide:
                    Constraint = new GenericPostureConstraintPerpendicularSlide(r);
                    break;
                case ConstraintType.ParallelSlide:
                    Constraint = new GenericPostureConstraintParallelSlide(r);
                    break;
                case ConstraintType.LockedInPlace:
                    Constraint = new GenericPostureConstraintLockedInPlace();
                    break;
                default:
                    string outerXml = r.ReadOuterXml();
                    log.DebugFormat("Unparsed content: {0}", outerXml);
                    break;
            }
            
            if(Constraint != null)
            {
                Constraint.Type = type;
                
                if(!string.IsNullOrEmpty(optionGroup))
                    Constraint.OptionGroup = optionGroup;
            }
            
            if(!isEmpty)
                r.ReadEndElement();
        }

19 Source : AutoNumber.cs
with GNU General Public License v2.0
from Kinovea

public void ReadXml(XmlReader xmlReader, PointF scale, TimestampMapper timestampMapper)
        {
            if(timestampMapper == null)
            {
                xmlReader.ReadOuterXml();
                return;                
            }

            if (xmlReader.MoveToAttribute("id"))
                identifier = new Guid(xmlReader.ReadContentreplacedtring());

            xmlReader.ReadStartElement();
            
            while(xmlReader.NodeType == XmlNodeType.Element)
            {
                switch(xmlReader.Name)
                {
                    case "Time":
                        position = timestampMapper(xmlReader.ReadElementContentAsLong());
                        break;
                    case "Location":
                        PointF p = XmlHelper.ParsePointF(xmlReader.ReadElementContentreplacedtring());
                        background.Rectangle = new RectangleF(p.Scale(scale.X, scale.Y), SizeF.Empty);
                        break;
                    case "Value":
                        value = xmlReader.ReadElementContentAsInt();
                        break;
                    default:
                        string unparsed = xmlReader.ReadOuterXml();
                        log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
                        break;
                }
            }
            
            xmlReader.ReadEndElement();
        }

19 Source : DrawingAngle.cs
with GNU General Public License v2.0
from Kinovea

public void ReadXml(XmlReader xmlReader, PointF scale, TimestampMapper timestampMapper)
        {
            if (xmlReader.MoveToAttribute("id"))
                identifier = new Guid(xmlReader.ReadContentreplacedtring());

            if (xmlReader.MoveToAttribute("name"))
                name = xmlReader.ReadContentreplacedtring();

            xmlReader.ReadStartElement();
            
            while(xmlReader.NodeType == XmlNodeType.Element)
            {
                switch(xmlReader.Name)
                {
                    case "PointO":
                        points["o"] = XmlHelper.ParsePointF(xmlReader.ReadElementContentreplacedtring());
                        break;
                    case "PointA":
                        points["a"] = XmlHelper.ParsePointF(xmlReader.ReadElementContentreplacedtring());
                        break;
                    case "PointB":
                        points["b"] = XmlHelper.ParsePointF(xmlReader.ReadElementContentreplacedtring());
                        break;
                    case "Signed":
                        signedAngle = XmlHelper.ParseBoolean(xmlReader.ReadElementContentreplacedtring());
                        break;
                    case "CCW":
                        counterClockwise = XmlHelper.ParseBoolean(xmlReader.ReadElementContentreplacedtring());
                        break;
                    case "Supplementary":
                        supplementaryAngle = XmlHelper.ParseBoolean(xmlReader.ReadElementContentreplacedtring());
                        break;
                    case "DrawingStyle":
                        style = new DrawingStyle(xmlReader);
                        BindStyle();
                        break;
                    case "InfosFading":
                        infosFading.ReadXml(xmlReader);
                        break;
                    case "Measure":
                        xmlReader.ReadOuterXml();
                        break;
                    default:
                        string unparsed = xmlReader.ReadOuterXml();
                        log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
                        break;
                }
            }
            
            xmlReader.ReadEndElement();
            initializing = false;

            points["o"] = points["o"].Scale(scale.X, scale.Y);
            points["a"] = points["a"].Scale(scale.X, scale.Y);
            points["b"] = points["b"].Scale(scale.X, scale.Y);
            SignalAllTrackablePointsMoved();
        }

19 Source : DrawingLine.cs
with GNU General Public License v2.0
from Kinovea

public void ReadXml(XmlReader xmlReader, PointF scale, TimestampMapper timestampMapper)
        {
            if (xmlReader.MoveToAttribute("id"))
                identifier = new Guid(xmlReader.ReadContentreplacedtring());

            if (xmlReader.MoveToAttribute("name"))
                name = xmlReader.ReadContentreplacedtring();

            xmlReader.ReadStartElement();
            
            while(xmlReader.NodeType == XmlNodeType.Element)
            {
                switch(xmlReader.Name)
                {
                    case "Start":
                        {
                            PointF p = XmlHelper.ParsePointF(xmlReader.ReadElementContentreplacedtring());
                            points["a"] = p.Scale(scale.X, scale.Y);
                            break;
                        }
                    case "End":
                        {
                            PointF p = XmlHelper.ParsePointF(xmlReader.ReadElementContentreplacedtring());
                            points["b"] = p.Scale(scale.X, scale.Y);
                            break;
                        }
                    case "ExtraData":
                        {
                            TypeConverter enumConverter = TypeDescriptor.GetConverter(typeof(TrackExtraData));
                            trackExtraData = (TrackExtraData)enumConverter.ConvertFromString(xmlReader.ReadElementContentreplacedtring());
                            break;
                        }
                    case "MeasureLabel":
                        {
                            miniLabel = new MiniLabel(xmlReader, scale);
                            break;
                        }
                    case "DrawingStyle":
                        style = new DrawingStyle(xmlReader);
                        BindStyle();
                        break;
                    case "InfosFading":
                        infosFading.ReadXml(xmlReader);
                        break;
                    case "Measure":
                        xmlReader.ReadOuterXml();
                        break;
                    default:
                        string unparsed = xmlReader.ReadOuterXml();
                        log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
                        break;
                }
            }
            
            xmlReader.ReadEndElement();
            initializing = false;
            measureInitialized = true;
            miniLabel.SetAttach(GetMiddlePoint(), false);
            miniLabel.BackColor = styleHelper.Color;
            SignalAllTrackablePointsMoved();
        }

19 Source : Keyframe.cs
with GNU General Public License v2.0
from Kinovea

private void ReadXml(XmlReader r, PointF scale, TimestampMapper timestampMapper)
        {
            if (r.MoveToAttribute("id"))
                id = new Guid(r.ReadContentreplacedtring());

            r.ReadStartElement();

            while (r.NodeType == XmlNodeType.Element)
            {
                switch (r.Name)
                {
                    case "Position":
                        int inputPosition = r.ReadElementContentAsInt();
                        position = timestampMapper(inputPosition);
                        break;
                    case "replacedle":
                        replacedle = r.ReadElementContentreplacedtring();
                        break;
                    case "Comment":
                        comments = r.ReadElementContentreplacedtring();
                        break;
                    case "Drawings":
                        ParseDrawings(r, scale);
                        break;
                    default:
                        string unparsed = r.ReadOuterXml();
                        log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
                        break;
                }
            }

            r.ReadEndElement();
        }

19 Source : DrawingDistortionGrid.cs
with GNU General Public License v2.0
from Kinovea

public void ReadXml(XmlReader xmlReader, PointF scale, TimestampMapper timestampMapper)
        {
            if (xmlReader.MoveToAttribute("id"))
                identifier = new Guid(xmlReader.ReadContentreplacedtring());
            
            if (xmlReader.MoveToAttribute("name"))
                name = xmlReader.ReadContentreplacedtring();
            
            xmlReader.ReadStartElement();

            while (xmlReader.NodeType == XmlNodeType.Element)
            {
                switch (xmlReader.Name)
                {
                    case "Points":
                        {
                            ParsePointList(xmlReader, scale);
                            break;
                        }
                    case "DrawingStyle":
                        style = new DrawingStyle(xmlReader);
                        BindStyle();
                        break;
                    case "InfosFading":
                        infosFading.ReadXml(xmlReader);
                        break;
                    default:
                        string unparsed = xmlReader.ReadOuterXml();
                        log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
                        break;
                }
            }

            xmlReader.ReadEndElement();

            initialized = true;
        }

19 Source : DrawingPlane.cs
with GNU General Public License v2.0
from Kinovea

public void ReadXml(XmlReader xmlReader, PointF scale, TimestampMapper timestampMapper)
        {
            if (xmlReader.MoveToAttribute("id"))
                identifier = new Guid(xmlReader.ReadContentreplacedtring());

            if (xmlReader.MoveToAttribute("name"))
                name = xmlReader.ReadContentreplacedtring();

            xmlReader.ReadStartElement();
            
            while(xmlReader.NodeType == XmlNodeType.Element)
            {
                switch(xmlReader.Name)
                {
                    case "PointUpperLeft":
                        {
                            quadImage.A = ReadPoint(xmlReader, scale); 
                            break;
                        }
                    case "PointUpperRight":
                        {
                            quadImage.B = ReadPoint(xmlReader, scale);
                            break;
                        }
                    case "PointLowerRight":
                        {
                            quadImage.C = ReadPoint(xmlReader, scale);
                            break;
                        }
                    case "PointLowerLeft":
                        {
                            quadImage.D = ReadPoint(xmlReader, scale);
                            break;
                        }
                    case "DrawingStyle":
                        style = new DrawingStyle(xmlReader);
                        BindStyle();
                        break;
                    case "InfosFading":
                        infosFading.ReadXml(xmlReader);
                        break;
                    default:
                        string unparsed = xmlReader.ReadOuterXml();
                        log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
                        break;
                }
            }
            
            xmlReader.ReadEndElement();
            
            if (!styleHelper.Perspective)
                planeIsConvex = quadImage.IsConvex;

            initialized = true;

            SignalAllTrackablePointsMoved();
        }

19 Source : DrawingPolyline.cs
with GNU General Public License v2.0
from Kinovea

public void ReadXml(XmlReader xmlReader, PointF scale, TimestampMapper timestampMapper)
        {
            if (xmlReader.MoveToAttribute("id"))
                identifier = new Guid(xmlReader.ReadContentreplacedtring());

            if (xmlReader.MoveToAttribute("name"))
                name = xmlReader.ReadContentreplacedtring();

            xmlReader.ReadStartElement();

            while (xmlReader.NodeType == XmlNodeType.Element)
            {
                switch (xmlReader.Name)
                {
                    case "PointList":
                        ParsePointList(xmlReader, scale);
                        break;
                    case "DrawingStyle":
                        style = new DrawingStyle(xmlReader);
                        BindStyle();
                        break;
                    case "InfosFading":
                        infosFading.ReadXml(xmlReader);
                        break;
                    default:
                        string unparsed = xmlReader.ReadOuterXml();
                        log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
                        break;
                }
            }


            xmlReader.ReadEndElement();
            initializing = false;

            SignalAllTrackablePointsMoved();
        }

19 Source : DrawingPolyline.cs
with GNU General Public License v2.0
from Kinovea

private void ParsePointList(XmlReader xmlReader, PointF scale)
        {
            points.Clear();

            xmlReader.ReadStartElement();

            while (xmlReader.NodeType == XmlNodeType.Element)
            {
                if (xmlReader.Name == "Point")
                {
                    string key = "0";
                    if (xmlReader.MoveToAttribute("key"))
                        key = xmlReader.ReadContentreplacedtring();

                    if (points.ContainsKey(key))
                        continue;

                    xmlReader.MoveToContent();
                    PointF p = XmlHelper.ParsePointF(xmlReader.ReadElementContentreplacedtring());
                    PointF adapted = p.Scale(scale.X, scale.Y);

                    points[key] = adapted;
                }
                else
                {
                    string unparsed = xmlReader.ReadOuterXml();
                    log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
                }
            }

            xmlReader.ReadEndElement();
        }

19 Source : DrawingText.cs
with GNU General Public License v2.0
from Kinovea

public void ReadXml(XmlReader xmlReader, PointF scale, TimestampMapper timestampMapper)
        {
            if (xmlReader.MoveToAttribute("id"))
                identifier = new Guid(xmlReader.ReadContentreplacedtring());

            if (xmlReader.MoveToAttribute("name"))
                name = xmlReader.ReadContentreplacedtring();

            xmlReader.ReadStartElement();
            
            while(xmlReader.NodeType == XmlNodeType.Element)
            {
                switch(xmlReader.Name)
                {
                    case "Text":
                        text = xmlReader.ReadElementContentreplacedtring();
                        text = TextHelper.FixMissingCarriageReturns(text);
                        break;
                    case "Position":
                        PointF p = XmlHelper.ParsePointF(xmlReader.ReadElementContentreplacedtring());
                        background.Rectangle = new RectangleF(p.Scale(scale.X, scale.Y), SizeF.Empty);
                        break;
                    case "ArrowVisible":
                        showArrow = XmlHelper.ParseBoolean(xmlReader.ReadElementContentreplacedtring());
                        break;
                    case "ArrowEnd":
                        arrowEnd = XmlHelper.ParsePointF(xmlReader.ReadElementContentreplacedtring());
                        break;
                    case "DrawingStyle":
                        style = new DrawingStyle(xmlReader);
                        BindStyle();
                        break;
                    case "InfosFading":
                        infosFading.ReadXml(xmlReader);
                        break;
                    default:
                        string unparsed = xmlReader.ReadOuterXml();
                        log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
                        break;
                }
            }
            
            xmlReader.ReadEndElement();
            UpdateLabelRectangle();
        }

19 Source : DrawingTracker.cs
with GNU General Public License v2.0
from Kinovea

private void ParseTrackablePoint(XmlReader r, PointF scale, TimestampMapper timeMapper)
        {
            string key = "";
            
            bool isEmpty = r.IsEmptyElement;

            if (r.MoveToAttribute("key"))
                key = r.ReadContentreplacedtring();

            TrackablePoint point = new TrackablePoint(r, scale, timeMapper);
            trackablePoints.Add(key, point);
        }

19 Source : DrawingGenericPosture.cs
with GNU General Public License v2.0
from Kinovea

public void ReadXml(XmlReader xmlReader, PointF scale, TimestampMapper timestampMapper)
        {
            // The tool id must be read before the point list.
            
            if (xmlReader.MoveToAttribute("id"))
                identifier = new Guid(xmlReader.ReadContentreplacedtring());

            if (xmlReader.MoveToAttribute("name"))
                name = xmlReader.ReadContentreplacedtring();

            xmlReader.ReadStartElement();
            while (xmlReader.NodeType == XmlNodeType.Element)
            {
                switch (xmlReader.Name)
                {
                    case "ToolId":
                        toolId = new Guid(xmlReader.ReadElementContentreplacedtring());
                        genericPosture = GenericPostureManager.Instanciate(toolId, true);
                        break;
                    case "Positions":
                        if(genericPosture != null)
                            ParsePointList(xmlReader, scale);
                        else
                            xmlReader.ReadOuterXml();
                        break;
                   case "DrawingStyle":
                        style = new DrawingStyle(xmlReader);
                        BindStyle();
                        break;
                    case "InfosFading":
                        infosFading.ReadXml(xmlReader);
                        break;
                    default:
                        string unparsed = xmlReader.ReadOuterXml();
                        log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
                        break;
                }
            }
            
            xmlReader.ReadEndElement();
            SignalAllTrackablePointsMoved();

            if (genericPosture != null)
                InitOptionMenus();
            else
                genericPosture = new GenericPosture("", true, false);
        }

19 Source : DrawingBitmap.cs
with GNU General Public License v2.0
from Kinovea

public void ReadXml(XmlReader xmlReader, PointF scale, TimestampMapper timestampMapper)
        {
            if (xmlReader.MoveToAttribute("id"))
                identifier = new Guid(xmlReader.ReadContentreplacedtring());

            if (xmlReader.MoveToAttribute("name"))
                name = xmlReader.ReadContentreplacedtring();

            xmlReader.ReadStartElement();
            
            while(xmlReader.NodeType == XmlNodeType.Element)
            {
                switch(xmlReader.Name)
                {
                    case "File":
                        filename = xmlReader.ReadElementContentreplacedtring();
                        break;
                    case "BoundingBox":
                        RectangleF rect = XmlHelper.ParseRectangleF(xmlReader.ReadElementContentreplacedtring());
                        boundingBox.Rectangle = rect.ToRectangle();
                        break;
                    case "Bitmap":
                        bitmap = XmlHelper.ParseImageFromBase64(xmlReader.ReadElementContentreplacedtring());
                        break;
                    case "InfosFading":
                        infosFading.ReadXml(xmlReader);
                        break;
                    default:
                        string unparsed = xmlReader.ReadOuterXml();
                        log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
                        break;
                }
            }

            xmlReader.ReadEndElement();

            if (bitmap != null)
                filename = null;

            if (bitmap == null && !string.IsNullOrEmpty(filename) && File.Exists(filename))
                bitmap = new Bitmap(filename);

            valid = bitmap != null;
        }

19 Source : DrawingCoordinateSystem.cs
with GNU General Public License v2.0
from Kinovea

public void ReadXml(XmlReader r)
        {
            if (r.MoveToAttribute("id"))
                identifier = new Guid(r.ReadContentreplacedtring());

            r.ReadStartElement();
            
            while(r.NodeType == XmlNodeType.Element)
            {
                switch (r.Name)
                {
                    case "Visible":
                        Visible = XmlHelper.ParseBoolean(r.ReadElementContentreplacedtring());
                        break;
                    case "DrawingStyle":
                        style = new DrawingStyle(r);
                        BindStyle();
                        break;
                    default:
                        string unparsed = r.ReadOuterXml();
                        break;
                }
            }

            r.ReadEndElement();
        }

19 Source : DrawingChrono.cs
with GNU General Public License v2.0
from Kinovea

public void ReadXml(XmlReader xmlReader, PointF scale, TimestampMapper timestampMapper)
        {
            if (xmlReader.MoveToAttribute("id"))
                identifier = new Guid(xmlReader.ReadContentreplacedtring());

            if (xmlReader.MoveToAttribute("name"))
                name = xmlReader.ReadContentreplacedtring();

            xmlReader.ReadStartElement();
            
            while(xmlReader.NodeType == XmlNodeType.Element)
            {
                switch(xmlReader.Name)
                {
                    case "Position":
                        PointF p = XmlHelper.ParsePointF(xmlReader.ReadElementContentreplacedtring());
                        mainBackground.Rectangle = new RectangleF(p.Scale(scale.X, scale.Y), SizeF.Empty);
                        break;
                    case "Values":
                        ParseWorkingValues(xmlReader, timestampMapper);
                        break;
                    case "DrawingStyle":
                        style = new DrawingStyle(xmlReader);
                        BindStyle();
                        break;
                    case "Label":
                        ParseLabel(xmlReader);
                        break;
                    default:
                        string unparsed = xmlReader.ReadOuterXml();
                        log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
                        break;
                }
            }
            
            xmlReader.ReadEndElement();
            SanityCheckValues();
        }

19 Source : DrawingCircle.cs
with GNU General Public License v2.0
from Kinovea

public void ReadXml(XmlReader xmlReader, PointF scale, TimestampMapper timestampMapper)
        {
            if (xmlReader.MoveToAttribute("id"))
                identifier = new Guid(xmlReader.ReadContentreplacedtring());

            if (xmlReader.MoveToAttribute("name"))
                name = xmlReader.ReadContentreplacedtring();

            xmlReader.ReadStartElement();
            
            while(xmlReader.NodeType == XmlNodeType.Element)
            {
                switch(xmlReader.Name)
                {
                    case "Origin":
                        PointF p = XmlHelper.ParsePointF(xmlReader.ReadElementContentreplacedtring());
                        center = p.Scale(scale.X, scale.Y);
                        break;
                    case "Radius":
                        radius = (int)(xmlReader.ReadElementContentAsInt() * Math.Min(scale.X, scale.Y));
                        break;
                    case "ExtraData":
                        {
                            TypeConverter enumConverter = TypeDescriptor.GetConverter(typeof(TrackExtraData));
                            trackExtraData = (TrackExtraData)enumConverter.ConvertFromString(xmlReader.ReadElementContentreplacedtring());
                            break;
                        }
                    case "MeasureLabel":
                        {
                            miniLabel = new MiniLabel(xmlReader, scale);
                            break;
                        }
                    case "ShowCenter":
                        showCenter = XmlHelper.ParseBoolean(xmlReader.ReadElementContentreplacedtring());
                        break;
                    case "DrawingStyle":
                        style = new DrawingStyle(xmlReader);
                        BindStyle();
                        break;
                    case "InfosFading":
                        infosFading.ReadXml(xmlReader);
                        break;
                    default:
                        string unparsed = xmlReader.ReadOuterXml();
                        log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
                        break;
                }
            }
            
            xmlReader.ReadEndElement();
            initializing = false;
            measureInitialized = true;
            miniLabel.SetAttach(center, false);
            miniLabel.BackColor = styleHelper.Color;
        }

19 Source : DrawingPencil.cs
with GNU General Public License v2.0
from Kinovea

public void ReadXml(XmlReader xmlReader, PointF scale, TimestampMapper timestampMapper)
        {
            if (xmlReader.MoveToAttribute("id"))
                identifier = new Guid(xmlReader.ReadContentreplacedtring());

            if (xmlReader.MoveToAttribute("name"))
                name = xmlReader.ReadContentreplacedtring();

            xmlReader.ReadStartElement();
            
            while(xmlReader.NodeType == XmlNodeType.Element)
            {
                switch(xmlReader.Name)
                {
                    case "PointList":
                        ParsePointList(xmlReader, scale);
                        break;
                    case "DrawingStyle":
                        style = new DrawingStyle(xmlReader);
                        BindStyle();
                        break;
                    case "InfosFading":
                        infosFading.ReadXml(xmlReader);
                        break;
                    default:
                        string unparsed = xmlReader.ReadOuterXml();
                        log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
                        break;
                }
            }
            
            xmlReader.ReadEndElement();
            initializing = false;
        }

19 Source : DrawingRectangle.cs
with GNU General Public License v2.0
from Kinovea

public void ReadXml(XmlReader xmlReader, PointF scale, TimestampMapper timestampMapper)
        {
            if (xmlReader.MoveToAttribute("id"))
                identifier = new Guid(xmlReader.ReadContentreplacedtring());

            if (xmlReader.MoveToAttribute("name"))
                name = xmlReader.ReadContentreplacedtring();

            xmlReader.ReadStartElement();
            
            while(xmlReader.NodeType == XmlNodeType.Element)
            {
                switch(xmlReader.Name)
                {
                    case "PointUpperLeft":
                        {
                            PointF p = XmlHelper.ParsePointF(xmlReader.ReadElementContentreplacedtring());
                            quadImage.A = p.Scale(scale.X, scale.Y);
                            break;
                        }
                    case "PointUpperRight":
                        {
                            PointF p = XmlHelper.ParsePointF(xmlReader.ReadElementContentreplacedtring());
                            quadImage.B = p.Scale(scale.X, scale.Y);
                            break;
                        }
                    case "PointLowerRight":
                        {
                            PointF p = XmlHelper.ParsePointF(xmlReader.ReadElementContentreplacedtring());
                            quadImage.C = p.Scale(scale.X, scale.Y);
                            break;
                        }
                    case "PointLowerLeft":
                        {
                            PointF p = XmlHelper.ParsePointF(xmlReader.ReadElementContentreplacedtring());
                            quadImage.D = p.Scale(scale.X, scale.Y);
                            break;
                        }
                    case "DrawingStyle":
                        style = new DrawingStyle(xmlReader);
                        BindStyle();
                        break;
                    case "InfosFading":
                        infosFading.ReadXml(xmlReader);
                        break;
                    default:
                        string unparsed = xmlReader.ReadOuterXml();
                        log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
                        break;
                }
            }
            
            xmlReader.ReadEndElement();
            initializing = false;
        }

19 Source : DrawingCrossMark.cs
with GNU General Public License v2.0
from Kinovea

public void ReadXml(XmlReader xmlReader, PointF scale, TimestampMapper timestampMapper)
        {
            if (xmlReader.MoveToAttribute("id"))
                identifier = new Guid(xmlReader.ReadContentreplacedtring());

            if (xmlReader.MoveToAttribute("name"))
                name = xmlReader.ReadContentreplacedtring();

            xmlReader.ReadStartElement();
            
            while(xmlReader.NodeType == XmlNodeType.Element)
            {
                switch(xmlReader.Name)
                {
                    case "CenterPoint":
                        PointF p = XmlHelper.ParsePointF(xmlReader.ReadElementContentreplacedtring());
                        points["0"] = p.Scale(scale.X, scale.Y);
                        break;
                    case "ExtraData":
                        {
                            TypeConverter enumConverter = TypeDescriptor.GetConverter(typeof(TrackExtraData));
                            trackExtraData = (TrackExtraData)enumConverter.ConvertFromString(xmlReader.ReadElementContentreplacedtring());
                            break;
                        }
                    case "MeasureLabel":
                        {
                            miniLabel = new MiniLabel(xmlReader, scale);
                            break;
                        }
                    case "DrawingStyle":
                        style = new DrawingStyle(xmlReader);
                        BindStyle();
                        break;
                    case "InfosFading":
                        infosFading.ReadXml(xmlReader);
                        break;
                    case "Coordinates":
                        xmlReader.ReadOuterXml();
                        break;
                    default:
                        string unparsed = xmlReader.ReadOuterXml();
                        log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
                        break;
                }
            }
            
            xmlReader.ReadEndElement();
            measureInitialized = true;
            miniLabel.SetAttach(points["0"], false);
            miniLabel.BackColor = styleHelper.Color;
            SignalTrackablePointMoved();
        }

19 Source : DrawingSVG.cs
with GNU General Public License v2.0
from Kinovea

public void ReadXml(XmlReader xmlReader, PointF scale, TimestampMapper timestampMapper)
        {
            if (xmlReader.MoveToAttribute("id"))
                identifier = new Guid(xmlReader.ReadContentreplacedtring());

            if (xmlReader.MoveToAttribute("name"))
                name = xmlReader.ReadContentreplacedtring();

            xmlReader.ReadStartElement();

            while (xmlReader.NodeType == XmlNodeType.Element)
            {
                switch (xmlReader.Name)
                {
                    case "File":
                        filename = xmlReader.ReadElementContentreplacedtring();
                        break;
                    case "InfosFading":
                        infosFading.ReadXml(xmlReader);
                        break;
                    default:
                        string unparsed = xmlReader.ReadOuterXml();
                        log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
                        break;
                }
            }

            xmlReader.ReadEndElement();

            LoadSVG(filename);
        }

19 Source : Spotlight.cs
with GNU General Public License v2.0
from Kinovea

public void ReadXml(XmlReader xmlReader, PointF scale, TimestampMapper timeStampMapper)
        {
            if (timeStampMapper == null)
                timeStampMapper = TimeHelper.IdenreplacedyTimestampMapper;
            
            if (xmlReader.MoveToAttribute("id"))
                identifier = new Guid(xmlReader.ReadContentreplacedtring());

            xmlReader.ReadStartElement();
            
            while(xmlReader.NodeType == XmlNodeType.Element)
            {
                switch(xmlReader.Name)
                {
                    case "Time":
                        position = timeStampMapper(xmlReader.ReadElementContentAsLong());
                        break;
                    case "Center":
                        PointF p = XmlHelper.ParsePointF(xmlReader.ReadElementContentreplacedtring());
                        points["o"] = p.Scale(scale.X, scale.Y);
                        break;
                    case "Radius":
                        radius = xmlReader.ReadElementContentAsInt();
                        float minScale = Math.Min(scale.X, scale.Y);
                        radius = (int)(radius * minScale);
                        break;
                    default:
                        string unparsed = xmlReader.ReadOuterXml();
                        log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
                        break;
                }
            }
            
            xmlReader.ReadEndElement();
            SignalTrackablePointMoved();
        }

19 Source : TrackingProfile.cs
with GNU General Public License v2.0
from Kinovea

public void ReadXml(XmlReader r)
        {
            r.ReadStartElement();

            while (r.NodeType == XmlNodeType.Element)
            {
                switch (r.Name)
                {
                    case "SimilarityThreshold":
                        SimilarityThreshold = double.Parse(r.ReadElementContentreplacedtring(), CultureInfo.InvariantCulture);
                        break;
                    case "TemplateUpdateThreshold":
                        TemplateUpdateThreshold = double.Parse(r.ReadElementContentreplacedtring(), CultureInfo.InvariantCulture);
                        break;
                    case "SearchWindow":
                        if (r.MoveToAttribute("unit"))
                            SearchWindowUnit = (TrackerParameterUnit)Enum.Parse(typeof(TrackerParameterUnit), r.ReadContentreplacedtring());

                        r.ReadStartElement();
                        SearchWindow = XmlHelper.ParseSize(r.ReadContentreplacedtring());
                        r.ReadEndElement();
                        break;
                    case "BlockWindow":
                        if (r.MoveToAttribute("unit"))
                            BlockWindowUnit = (TrackerParameterUnit)Enum.Parse(typeof(TrackerParameterUnit), r.ReadContentreplacedtring());

                        r.ReadStartElement();
                        BlockWindow = XmlHelper.ParseSize(r.ReadContentreplacedtring());
                        r.ReadEndElement();
                        break;
                    case "RefinementNeighborhood":
                        RefinementNeighborhood = int.Parse(r.ReadElementContentreplacedtring(), CultureInfo.InvariantCulture);
                        break;
                    case "ResetOnMove":
                        ResetOnMove = XmlHelper.ParseBoolean(r.ReadElementContentreplacedtring());
                        break;
                    default:
                        string outerXml = r.ReadOuterXml();
                        log.DebugFormat("Unparsed content in XML: {0}", outerXml);
                        break;
                }
            }

            r.ReadEndElement();

            SimilarityThreshold = Math.Min(1.0, SimilarityThreshold);
            TemplateUpdateThreshold = Math.Min(1.0, TemplateUpdateThreshold);

            if (BlockWindow.Width >= SearchWindow.Width || BlockWindow.Height >= SearchWindow.Height)
                BlockWindow = new Size(SearchWindow.Width / 2, SearchWindow.Height / 2);
        }

19 Source : VirtualKeyBoard.cs
with GNU General Public License v3.0
from logicpulse

private bool AddKey(XmlReader reader)
        {
            String currentType = "";
            int currentRowIndex = 0;
            int currentColIndex = 0;
            int currentLevel = 0;
            bool result = false;

            try
            {
                //Get Attributes from Node
                if (reader.MoveToAttribute("type")) currentType = reader.ReadContentreplacedtring();
                if (reader.MoveToAttribute("row")) currentRowIndex = reader.ReadContentAsInt();
                if (reader.MoveToAttribute("col")) currentColIndex = reader.ReadContentAsInt();
                if (reader.MoveToAttribute("level")) currentLevel = reader.ReadContentAsInt();

                //Always Validate if position exists, if not Allocate space to it
                ValidateKeyBoard(currentRowIndex, currentColIndex);

                //Init tmpSelectedKey
                VirtualKey tmpSelectedKey = null;

                //Create reference to position in VirtualKeyboard 
                tmpSelectedKey = _internalKeyBoard[currentRowIndex][currentColIndex];

                //Init key position
                if (tmpSelectedKey.RowIndex == -1) tmpSelectedKey.RowIndex = currentRowIndex;
                if (tmpSelectedKey.ColIndex == -1) tmpSelectedKey.ColIndex = currentColIndex;

                //Get Attributes from node and replacedign to Leve Properties
                VirtualKeyProperties tmpProperties = new VirtualKeyProperties();
                if (reader.MoveToAttribute("glyph")) tmpProperties.Glyph = reader.ReadContentreplacedtring();
                if (reader.MoveToAttribute("ibmid")) tmpProperties.IbmId = reader.ReadContentreplacedtring();
                if (reader.MoveToAttribute("deadkey")) tmpProperties.IsDeadKey = reader.ReadContentAsBoolean();
                if (reader.MoveToAttribute("diacritical")) tmpProperties.Diacritical = reader.ReadContentreplacedtring();
                if (reader.MoveToAttribute("notengraved")) tmpProperties.IsNotEngraved = reader.ReadContentAsBoolean();
                if (reader.MoveToAttribute("charactername")) tmpProperties.CharacterName = reader.ReadContentreplacedtring();
                if (reader.MoveToAttribute("unicodeid")) tmpProperties.UnicodeId = reader.ReadContentreplacedtring();
                if (reader.MoveToAttribute("keywidth")) tmpProperties.KeyWidth = reader.ReadContentAsInt();
                if (reader.MoveToAttribute("numpad")) tmpProperties.IsNumPad = reader.ReadContentAsBoolean();
                if (reader.MoveToAttribute("hidel2")) tmpProperties.HideL2 = reader.ReadContentAsBoolean();
                if (reader.MoveToAttribute("bold")) tmpProperties.IsBold = reader.ReadContentAsBoolean();
                if (reader.MoveToAttribute("halign")) tmpProperties.HAlign = reader.ReadContentreplacedtring();

                switch (currentLevel)
                {
                    case 0:
                        tmpSelectedKey.Type = currentType;
                        tmpSelectedKey.L1 = tmpProperties;
                        break;
                    case 1:
                        tmpSelectedKey.L2 = tmpProperties;
                        break;
                    case 2:
                        tmpSelectedKey.L3 = tmpProperties;
                        break;
                    default:
                        throw new Exception("Invalid key level");
                }
            }
            catch (Exception ex)
            {
                _log.Error(string.Format("AddKey(): {0}", ex.Message), ex);
            }

            return (result);
        }

19 Source : UpdateNode.cs
with MIT License
from microsoft

void IXmlSerializable.ReadXml (XmlReader reader)
        {
            reader.MoveToContent ();

            Id = reader.GetAttribute ("id");
            Level = reader.GetAttribute ("level");
            Version = reader.GetAttribute ("version");

            long versionId;
            long.TryParse (reader.GetAttribute ("versionId"), out versionId);
            VersionId = versionId;

            try {
                Date = XmlConvert.ToDateTime (
                    reader.GetAttribute ("date"),
                    XmlDateTimeSerializationMode.RoundtripKind);
            } catch {
                Date = DateTime.MinValue;
            }

            try {
                Url = new Uri (reader.GetAttribute ("url"));
            } catch {
                Url = null;
            }

            Hash = reader.GetAttribute ("hash");

            long size;
            long.TryParse (reader.GetAttribute ("size"), out size);
            Size = size;

            Restart = String.Equals (
                reader.GetAttribute ("restart"),
                "true",
                StringComparison.InvariantCultureIgnoreCase);

            Interactive = String.Equals (
                reader.GetAttribute ("interactive"),
                "true",
                StringComparison.InvariantCultureIgnoreCase);

            ReleaseNotes = reader.Value;

            var isEmptyElement = reader.IsEmptyElement;

            reader.ReadStartElement ();

            if (isEmptyElement) {
                ReleaseNotes = null;
            } else {
                ReleaseNotes = reader.ReadContentreplacedtring ();
                reader.ReadEndElement ();
            }
        }

See More Examples