System.Xml.XmlReader.ReadElementContentAsInt()

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

20 Examples 7

19 Source : ExcelWorksheet.cs
with Apache License 2.0
from Appdynamics

private void SetValueFromXml(XmlReader xr, string type, int styleID, int row, int col)
        {
            //XmlNode vnode = colNode.SelectSingleNode("d:v", NameSpaceManager);
            //if (vnode == null) return null;
            if (type == "s")
            {
                int ix = xr.ReadElementContentAsInt();
                SetValueInner(row, col, _package.Workbook._sharedStringsList[ix].Text);
                if (_package.Workbook._sharedStringsList[ix].isRichText)
                {
                    _flags.SetFlagValue(row, col, true, CellFlags.RichText);
                }
            }
            else if (type == "str")
            {
                SetValueInner(row, col, ConvertUtil.ExcelDecodeString(xr.ReadElementContentreplacedtring()));
            }
            else if (type == "b")
            {
                SetValueInner(row, col, (xr.ReadElementContentreplacedtring() != "0"));
            }
            else if (type == "e")
            {
                SetValueInner(row, col, GetErrorType(xr.ReadElementContentreplacedtring()));
            }
            else
            {
                string v = xr.ReadElementContentreplacedtring();
                var nf = Workbook.Styles.CellXfs[styleID].NumberFormatId;
                if ((nf >= 14 && nf <= 22) || (nf >= 45 && nf <= 47))
                {
                    double res;
                    if (double.TryParse(v, NumberStyles.Any, CultureInfo.InvariantCulture, out res))
                    {
                        if (Workbook.Date1904)
                        {
                            res += ExcelWorkbook.date1904Offset;
                        }
                        if (res >= -657435.0 && res < 2958465.9999999)
                        {
                            SetValueInner(row, col, DateTime.FromOADate(res));
                        }
                        else
                        {
                            SetValueInner(row, col, res);
                        }
                    }
                    else
                    {
                        SetValueInner(row, col, v);
                    }
                }
                else
                {
                    double d;
                    if (double.TryParse(v, NumberStyles.Any, CultureInfo.InvariantCulture, out d))
                    {
                        SetValueInner(row, col, d);
                    }
                    else
                    {
                        SetValueInner(row, col, double.NaN);
                    }
                }
            }
        }

19 Source : CustomUpdate.cs
with MIT License
from DCourtel

private void SetReturnCodeFromXml(XmlReader reader)
        {
            if (reader.ReadToFollowing("Method"))
            {
                string method = reader.ReadElementContentreplacedtring();
                switch (method)
                {
                    case "Variable":
                        this.ReturnCodeMethod = ReturnCode.Variable;
                        break;
                    case "Static":
                        this.ReturnCodeMethod = ReturnCode.Static;
                        if (reader.ReadToFollowing("Code"))
                        {
                            int code = reader.ReadElementContentAsInt();
                            this.StaticCode = code;
                        }
                        else
                            if (this.IsUIEnable)
                                System.Windows.Forms.MessageBox.Show(Localizator.Getinstance().GetLocalizedString("UnableToSetReturnCodeFromXmlFile"));
                            else
                                throw new Exception(Localizator.Getinstance().GetLocalizedString("UnableToSetReturnCodeFromXmlFile"));
                        break;
                    default:
                        if (this.IsUIEnable)
                            System.Windows.Forms.MessageBox.Show(Localizator.Getinstance().GetLocalizedString("UnableToSetReturnCodeFromXmlFile"));
                        else
                            throw new Exception(Localizator.Getinstance().GetLocalizedString("UnableToSetReturnCodeFromXmlFile"));
                        break;
                }
            }
            else
            {
                if (this.IsUIEnable)
                    System.Windows.Forms.MessageBox.Show(Localizator.Getinstance().GetLocalizedString("UnableToSetReturnCodeFromXmlFile"));
                else
                    throw new Exception(Localizator.Getinstance().GetLocalizedString("UnableToSetReturnCodeFromXmlFile"));
            }
        }

19 Source : EventRecord.cs
with MIT License
from EricZimmerman

public void BuildProperties()
        {
            var l = LogManager.GetLogger("EventRecord");
            var xml = ConvertPayloadToXml();

            var reader = XmlReader.Create(new StringReader(xml));
            reader.MoveToContent();
            // Parse the file and display each of the nodes.
            while (reader.Read())
            {
                if (reader.IsStartElement())
                {
                    switch (reader.Name)
                    {
                        case "Computer":
                            reader.Read();
                            Computer = reader.Value;
                            break;
                        case "Channel":
                            reader.Read();
                            Channel = reader.Value;
                            break;
                        case "EventRecordID":
                            EventRecordId = reader.ReadElementContentreplacedtring();
                            break;
                        case "EventID":
                            EventId = reader.ReadElementContentAsInt();
                            break;
                        case "Level":
                            var lvl = reader.ReadElementContentAsInt();
                            
                            switch (lvl)
                            {
                                case 0:
                                    Level = "LogAlways";
                                    break;
                                case 1:
                                    Level = "Critical";
                                    break;
                                case 2:
                                    Level = "Error";
                                    break;
                                case 3:
                                    Level = "Warning";
                                    break;
                                case 4:
                                    Level = "Info";
                                    break;
                                case 5:
                                    Level = "Verbose";
                                    break;
                            
                                case 8:
                                    Level = "Success";
                                    break;
                                case 16:
                                    Level = "Failure";
                                    break;
                                default:
                                    Level = lvl.ToString();
                                    break;
                            }

                            break;

                        case "Keywords":

                            var kw = reader.ReadElementContentreplacedtring();

                            switch (kw)
                            {
                                case "0x8010000000000000":
                                    Keywords = "Audit failure";
                                    break;
                                case "0x8020000000000000":
                                    Keywords = "Audit success";
                                    break;
                                case "0x8000000000000010":
                                    Keywords = "Time";
                                    break;
                                case "0x8000000000000080":
                                    Keywords = "State";
                                    break;
                                case "0x8000000000000040":
                                    Keywords = "Reboot";
                                    break;
                                case "0x8000000000000018":
                                    Keywords = "Installation";
                                    break;
                                case "0x8000000000000014":
                                    Keywords = "Download";
                                    break;
                                case "0x8080000000000000":
                                    Keywords = "Audit success, clreplacedic";
                                    break;
                                case "0x8000000000000000":
                                    Keywords = "Clreplacedic";
                                    break;
                                default:
                                    Keywords = kw;
                                    break;
                            }

                                break;

                        case "TimeCreated":
                            var st = reader.GetAttribute("SystemTime");
                            TimeCreated = DateTimeOffset.Parse(st, null, DateTimeStyles.replacedumeUniversal).ToUniversalTime();
                            break;
                        case "Provider":
                            Provider = reader.GetAttribute("Name");
                            break;
                        case "Execution":
                            var pid = reader.GetAttribute("ProcessID");
                            var tid = reader.GetAttribute("ThreadID");
                            if (pid!=null)
                            {
                                ProcessId = int.Parse(pid);
                            }

                            if (tid != null)
                            {
                                ThreadId = int.Parse(tid);
                            }
                            
                            break;
                        case "Security":
                            UserId = reader.GetAttribute("UserID");
                            break;
                      
                        case "EventData":
                        case "UserData":
                            Payload = reader.ReadOuterXml();

                            break;
                    }
                }
            }

            if (Payload == null)
            {
                reader = XmlReader.Create(new StringReader(xml));
                reader.MoveToContent();

                reader.ReadToDescendant("System");
                reader.ReadOuterXml();
                reader.ReadOuterXml();
                Payload=  reader.ReadOuterXml();

            }

            if (EventLog.EventLogMaps.Count == 0)
            {
                return;
            }

            if (!EventLog.EventLogMaps.ContainsKey($"{EventId}-{Channel.ToUpperInvariant()}-{Provider.ToUpperInvariant()}"))
            {
                return;
            }

            var docNav = new XPathDoreplacedent(new StringReader(xml));
            var nav = docNav.CreateNavigator();

            l.Trace($"Found map for Event ID {EventId} with Channel '{Channel}' and Provider '{Provider}'!");
            var map = EventLog.EventLogMaps[$"{EventId}-{Channel.ToUpperInvariant()}-{Provider.ToUpperInvariant()}"];

            MapDescription = map.Description;

            l.Debug($"Processing map with description '{map.Description}', event id: {map.EventId}");

            foreach (var mapEntry in map.Maps)
            {
                var valProps = new Dictionary<string, string>();

                foreach (var me in mapEntry.Values)
                {
                    //xpath out variables
                    var propVal = nav.SelectSingleNode(me.Value); 
                    if (propVal != null)
                    {
                        var propValue = propVal.Value;

                        if (me.Refine.IsNullOrEmpty() == false)
                        {
                            var hits = new List<string>();

                            //regex time
                            try
                            {
                                var regexObj = new Regex(me.Refine, RegexOptions.IgnoreCase);
                                var allMatchResults = regexObj.Matches(propValue);
                                if (allMatchResults.Count > 0)
                                {
                                    // Access individual matches using allMatchResults.Item[]
                                    foreach (Match allMatchResult in allMatchResults)
                                    {
                                        hits.Add(allMatchResult.Value);
                                    }

                                    propValue = string.Join(" | ", hits);
                                }
                            }
                            catch (ArgumentException)
                            {
                                // Syntax error in the regular expression
                            }
                        }

                        var lu = map.Lookups?.SingleOrDefault(t =>
                            t.Name.ToUpperInvariant() == me.Name.ToUpperInvariant());

                        if (lu != null)
                        {
                           
                            if (lu.Values.ContainsKey(propValue))
                            {
                                propValue = lu.Values[propValue]; //set it to lookup value
                            }
                            else
                            {
                                propValue = $"{lu.Default} ({propValue})"; //include the default and original value
                            }
                        }

                        valProps.Add(me.Name, propValue);
                    }
                    else
                    {
                        valProps.Add(me.Name, string.Empty);
                        l.Warn(
                            $"Record # {RecordNumber} (Event Record Id: {EventRecordId}): In map for event '{map.EventId}', Property '{me.Value}' not found! Replacing with empty string");
                    }
                }

                //we have the values, now subsreplacedute
                var propertyValue = mapEntry.PropertyValue;
                foreach (var valProp in valProps)
                {
                    propertyValue = propertyValue.Replace($"%{valProp.Key}%", valProp.Value);
                }

                var propertyToUpdate = mapEntry.Property.ToUpperInvariant();

                if (valProps.Count == 0)
                {
                    propertyToUpdate = "NOMATCH"; //prevents variables from showing up in the CSV
                }

                //we should now have our new value, so stick it in its place
                switch (propertyToUpdate)
                {
                    case "USERNAME":
                        UserName = propertyValue;
                        break;
                    case "REMOTEHOST":
                        RemoteHost = propertyValue;
                        break;
                    case "EXECUTABLEINFO":
                        ExecutableInfo = propertyValue;
                        break;
                    case "PAYLOADDATA1":
                        PayloadData1 = propertyValue;
                        break;
                    case "PAYLOADDATA2":
                        PayloadData2 = propertyValue;
                        break;
                    case "PAYLOADDATA3":
                        PayloadData3 = propertyValue;
                        break;
                    case "PAYLOADDATA4":
                        PayloadData4 = propertyValue;
                        break;
                    case "PAYLOADDATA5":
                        PayloadData5 = propertyValue;
                        break;
                    case "PAYLOADDATA6":
                        PayloadData6 = propertyValue;
                        break;
                    case "NOMATCH":
                        //when a property was not found.
                        break;
                    default:
                        l.Warn(
                            $"Unknown property name '{propertyToUpdate}'! Dropping mapping value of '{propertyValue}'");
                        break;
                }
            }
        }

19 Source : VoiceManager.cs
with BSD 3-Clause "New" or "Revised" License
from HalcyonGrid

private void _DaemonPipe_OnReceiveLine(string line)
        {
            XmlTextReader reader = new XmlTextReader(new StringReader(line));

            while (reader.Read())
            {
                switch (reader.NodeType)
                {
                    case XmlNodeType.Element:
                    {
                        if (reader.Depth == 0)
                        {
                            isEvent = (reader.Name == "Event");

                            if (isEvent || reader.Name == "Response")
                            {
                                for (int i = 0; i < reader.AttributeCount; i++)
                                {
                                    reader.MoveToAttribute(i);

                                    switch (reader.Name)
                                    {
//                                         case "requestId":
//                                             uuidString = reader.Value;
//                                             break;
                                        case "action":
                                            actionString = reader.Value;
                                            break;
                                        case "type":
                                            eventTypeString = reader.Value;
                                            break;
                                    }
                                }
                            }
                        }
                        else
                        {
                            switch (reader.Name)
                            {
                                case "InputXml":
                                    cookie = -1;

                                    // Parse through here to get the cookie value
                                    reader.Read();
                                    if (reader.Name == "Request")
                                    {
                                        for (int i = 0; i < reader.AttributeCount; i++)
                                        {
                                            reader.MoveToAttribute(i);

                                            if (reader.Name == "requestId")
                                            {
                                                Int32.TryParse(reader.Value, out cookie);
                                                break;
                                            }
                                        }
                                    }

                                    if (cookie == -1)
                                    {
                                        Logger.Log("VoiceManager._DaemonPipe_OnReceiveLine(): Failed to parse InputXml for the cookie",
                                            Helpers.LogLevel.Warning, Client);
                                    }
                                    break;
                                case "CaptureDevices":
                                    _CaptureDevices.Clear();
                                    break;
                                case "RenderDevices":
                                    _RenderDevices.Clear();
                                    break;
//                                 case "ReturnCode":
//                                     returnCode = reader.ReadElementContentAsInt();
//                                     break;
                                case "StatusCode":
                                    statusCode = reader.ReadElementContentAsInt();
                                    break;
                                case "StatusString":
                                    statusString = reader.ReadElementContentreplacedtring();
                                    break;
                                case "State":
                                    state = reader.ReadElementContentAsInt();
                                    break;
                                case "ConnectorHandle":
                                    connectorHandle = reader.ReadElementContentreplacedtring();
                                    break;
                                case "AccountHandle":
                                    accountHandle = reader.ReadElementContentreplacedtring();
                                    break;
                                case "SessionHandle":
                                    sessionHandle = reader.ReadElementContentreplacedtring();
                                    break;
                                case "URI":
                                    uriString = reader.ReadElementContentreplacedtring();
                                    break;
                                case "IsChannel":
                                    isChannel = reader.ReadElementContentAsBoolean();
                                    break;
                                case "Name":
                                    nameString = reader.ReadElementContentreplacedtring();
                                    break;
//                                 case "AudioMedia":
//                                     audioMediaString = reader.ReadElementContentreplacedtring();
//                                     break;
                                case "ChannelName":
                                    nameString = reader.ReadElementContentreplacedtring();
                                    break;
                                case "ParticipantURI":
                                    uriString = reader.ReadElementContentreplacedtring();
                                    break;
                                case "DisplayName":
                                    displayNameString = reader.ReadElementContentreplacedtring();
                                    break;
                                case "AccountName":
                                    nameString = reader.ReadElementContentreplacedtring();
                                    break;
                                case "ParticipantType":
                                    participantType = reader.ReadElementContentAsInt();
                                    break;
                                case "IsLocallyMuted":
                                    isLocallyMuted = reader.ReadElementContentAsBoolean();
                                    break;
                                case "IsModeratorMuted":
                                    isModeratorMuted = reader.ReadElementContentAsBoolean();
                                    break;
                                case "IsSpeaking":
                                    isSpeaking = reader.ReadElementContentAsBoolean();
                                    break;
                                case "Volume":
                                    volume = reader.ReadElementContentAsInt();
                                    break;
                                case "Energy":
                                    energy = reader.ReadElementContentAsFloat();
                                    break;
                                case "MicEnergy":
                                    energy = reader.ReadElementContentAsFloat();
                                    break;
                                case "ChannelURI":
                                    uriString = reader.ReadElementContentreplacedtring();
                                    break;
                                case "ChannelListResult":
                                    _ChannelMap[nameString] = uriString;
                                    break;
                                case "CaptureDevice":
                                    reader.Read();
                                    _CaptureDevices.Add(reader.ReadElementContentreplacedtring());
                                    break;
                                case "CurrentCaptureDevice":
                                    reader.Read();
                                    nameString = reader.ReadElementContentreplacedtring();
                                    break;
                                case "RenderDevice":
                                    reader.Read();
                                    _RenderDevices.Add(reader.ReadElementContentreplacedtring());
                                    break;
                                case "CurrentRenderDevice":
                                    reader.Read();
                                    nameString = reader.ReadElementContentreplacedtring();
                                    break;
                            }
                        }

                        break;
                    }
                    case XmlNodeType.EndElement:
                        if (reader.Depth == 0)
                            ProcessEvent();
                        break;
                }
            }

            if (isEvent)
            {
            }

            //Client.DebugLog("VOICE: " + line);
        }

19 Source : Settings.cs
with GNU General Public License v3.0
from irusanov

private bool ReadSettingsFromFile()
        {
            try
            {
                using (FileStream fs = new FileStream(FullFilePath, FileMode.Open))
                {
                    using (XmlReader reader = XmlReader.Create(fs))
                    {

                        // Find ZenStates Element
                        while (reader.Read() && reader.NodeType == XmlNodeType.Element && reader.Name == "ZenStates") { }

                        // Find Application Element
                        while (reader.Read() && reader.NodeType == XmlNodeType.Element && reader.Name == "Application") { }

                        // Read Application Element variables
                        while (reader.Read() && reader.NodeType != XmlNodeType.EndElement)
                        {
                            if (reader.NodeType == XmlNodeType.Element)
                            {
                                switch (reader.Name)
                                {
                                    case "ServiceVersion": ServiceVersion = (byte)reader.ReadElementContentAsInt(); break;
                                    case "SettingsReset": SettingsReset = reader.ReadElementContentreplacedtring() == "True" ? true : false; break;
                                    case "LastState": LastState = (byte)reader.ReadElementContentAsInt(); break;
                                }
                            }
                        }

                        // Find Settings Element
                        while (reader.Read() && reader.NodeType == XmlNodeType.Element && reader.Name == "Settings") { }

                        // Read Settings Element variables
                        while (reader.Read() && reader.NodeType != XmlNodeType.EndElement)
                        {
                            if (reader.NodeType == XmlNodeType.Element)
                            {
                                switch (reader.Name)
                                {
                                    case "TrayIconAtStart": TrayIconAtStart = reader.ReadElementContentreplacedtring() == "True" ? true : false; break;
                                    case "ApplyAtStart": ApplyAtStart = reader.ReadElementContentreplacedtring() == "True" ? true : false; ; break;
                                    case "P80Temp": P80Temp = reader.ReadElementContentreplacedtring() == "True" ? true : false; break;
                                    case "P0": Pstate[0] = Convert.ToUInt64(reader.ReadElementContentreplacedtring(), 16); break;
                                    case "P1": Pstate[1] = Convert.ToUInt64(reader.ReadElementContentreplacedtring(),16); break;
                                    case "P2": Pstate[2] = Convert.ToUInt64(reader.ReadElementContentreplacedtring(),16); break;
                                    case "Boost0": BoostFreq[0] = Convert.ToUInt64(reader.ReadElementContentreplacedtring(), 16); break;
                                    case "Boost1": BoostFreq[1] = Convert.ToUInt64(reader.ReadElementContentreplacedtring(), 16); break;
                                    case "Boost2": BoostFreq[2] = Convert.ToUInt64(reader.ReadElementContentreplacedtring(), 16); break;
                                    case "PstateOc": PstateOc = Convert.ToUInt64(reader.ReadElementContentreplacedtring(), 16); break;
                                    case "ZenC6Core": ZenC6Core = reader.ReadElementContentreplacedtring() == "True" ? true : false; break;
                                    case "ZenC6Package": ZenC6Package = reader.ReadElementContentreplacedtring() == "True" ? true : false; break;
                                    case "ZenCorePerfBoost": ZenCorePerfBoost = reader.ReadElementContentreplacedtring() == "True" ? true : false; break;
                                    case "ZenOc": ZenOc = reader.ReadElementContentreplacedtring() == "True" ? true : false; break;
                                    case "ZenPPT": ZenPPT = reader.ReadElementContentAsInt(); break;
                                    case "ZenTDC": ZenTDC = reader.ReadElementContentAsInt(); break;
                                    case "ZenEDC": ZenEDC = reader.ReadElementContentAsInt(); break;
                                    case "ZenScalar": ZenScalar = reader.ReadElementContentAsInt(); break;
                                    case "PerformanceBias": PerformanceBias = (CPUHandler.PerfBias)reader.ReadElementContentAsInt(); break;
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                //throw new Exception("Settings: " + ex.Message);
                return false;
            }

            return true;
        }

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 : 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 : 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 : TrackerParameters.cs
with GNU General Public License v2.0
from Kinovea

public static TrackerParameters ReadXml(XmlReader r, PointF scale)
        {
            TrackingProfile clreplacedic = new TrackingProfile();
            double similarityThreshold = clreplacedic.SimilarityThreshold;
            double updateThreshold = clreplacedic.TemplateUpdateThreshold;
            int refinementNeighborhood = clreplacedic.RefinementNeighborhood;
            Size searchWindow = clreplacedic.SearchWindow;
            Size blockWindow = clreplacedic.BlockWindow;
            
            r.ReadStartElement();
            
            while(r.NodeType == XmlNodeType.Element)
            {
                switch (r.Name)
                {
                    case "SimilarityThreshold":
                        similarityThreshold = r.ReadElementContentAsDouble();
                        break;
                    case "TemplateUpdateThreshold":
                        updateThreshold = r.ReadElementContentAsDouble();
                        break;
                    case "RefinementNeighborhood":
                        refinementNeighborhood = r.ReadElementContentAsInt();
                        break;
                    case "SearchWindow":
                        searchWindow = XmlHelper.ParseSize(r.ReadElementContentreplacedtring());
                        searchWindow = new SizeF(searchWindow.Width * scale.X, searchWindow.Height * scale.Y).ToSize();
                        break;
                    case "BlockWindow":
                        blockWindow = XmlHelper.ParseSize(r.ReadElementContentreplacedtring());
                        blockWindow = new SizeF(blockWindow.Width * scale.X, blockWindow.Height * scale.Y).ToSize();
                        break;
                    default:
                        string outerXml = r.ReadOuterXml();
                        break;
                }
            }
            
            r.ReadEndElement();

            TrackerParameters parameters = new TrackerParameters(similarityThreshold, updateThreshold, refinementNeighborhood, searchWindow, blockWindow, false);
            return parameters;
        }

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

private void ReadXml(XmlReader r)
        {
            try
            {
                r.MoveToContent();
                
                if(!(r.Name == "KinoveaPostureTool"))
            	    return;
                
            	r.ReadStartElement();
                string formatVersion = r.ReadElementContentreplacedtring("FormatVersion", "");
                CheckFormatVersion(formatVersion);

                while (r.NodeType == XmlNodeType.Element)
    			{
                    switch(r.Name)
    				{
                        // Header section
                        case "Id":
                            Id = new Guid(r.ReadElementContentreplacedtring());
                            break;
                        case "Name":
                            Name = r.ReadElementContentreplacedtring();
                            break;
                        case "DisplayName":
                            DisplayName = r.ReadElementContentreplacedtring();
                            break;
                        case "Icon":
                             r.ReadOuterXml();
                            break;

                        // Data section

                        // Deprecated (1.0)
                        case "PointCount":
                            // Ignored.
                            r.ReadElementContentAsInt();
    						break;
                        case "InitialConfiguration":
                            ParseInitialConfiguration(r);
                            break;

                        case "Points":
                            ParsePoints(r);
                            break;
                        case "Segments":
    						ParseSegments(r);
    						break;
    					case "Ellipses":
                        case "Circles":
    						ParseCircles(r);
    						break;
    					case "Angles":
    						ParseAngles(r);
    						break;
                        case "Polylines":
                            ParsePolylines(r);
                            break;
                        // Interaction section
    					case "Handles":
    						ParseHandles(r);
    						break;
                        case "HitZone":
                            ParseHitZone(r);
                            break;

                        // Variables section
                        case "Distances":
    						ParseDistances(r);
    						break;
    				    case "Positions":
    						ParsePositions(r);
    						break;
                        case "ComputedPoints":
    						ParseComputedPoints(r);
    						break;

                        // Menus
                        case "Options":
                            ParseOptions(r);
                            break;
    		            case "Capabilities":
    						ParseCapabilities(r);
    						break;
                            
                        // Extra
                        case "TrackingProfile":
                            CustomTrackingProfile.ReadXml(r);
                            break;

                        default:
    						string unparsed = r.ReadOuterXml();
    						log.DebugFormat("Unparsed content in XML: {0}", unparsed);
    						break;
                    }
                }
                
                r.ReadEndElement();
                
                ConsolidateOptions();
            }
            catch(Exception e)
            {
                log.ErrorFormat("An error occurred during the parsing of a custom tool.");
                log.ErrorFormat(e.ToString());
            }
        }

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 : CapturePreferences.cs
with GNU General Public License v2.0
from Kinovea

public void ReadXML(XmlReader reader)
        {
            reader.ReadStartElement();

            while(reader.NodeType == XmlNodeType.Element)
            {
                switch(reader.Name)
                {
                    case "CapturePathConfiguration":
                        capturePathConfiguration.ReadXml(reader);
                        break;
                    case "DisplaySynchronizationFramerate":
                        string str = reader.ReadElementContentreplacedtring();
                        displaySynchronizationFramerate = double.Parse(str, CultureInfo.InvariantCulture);
                        break;
                    case "CaptureRecordingMode":
                        recordingMode = (CaptureRecordingMode)Enum.Parse(typeof(CaptureRecordingMode), reader.ReadElementContentreplacedtring());
                        break;
                    case "SaveUncompressedVideo":
                        saveUncompressedVideo = XmlHelper.ParseBoolean(reader.ReadElementContentreplacedtring());
                        break;
                    case "VerboseStats":
                        verboseStats = XmlHelper.ParseBoolean(reader.ReadElementContentreplacedtring());
                        break;
                    case "MemoryBuffer":
                        memoryBuffer = reader.ReadElementContentAsInt();
                        break;
                    case "Cameras":
                        ParseCameras(reader);
                        break;
                    case "DelayCompositeConfiguration":
                        delayCompositeConfiguration.ReadXml(reader);
                        break;
                    case "PhotofinishConfiguration":
                        photofinishConfiguration.ReadXml(reader);
                        break;
                    case "CaptureAutomationConfiguration":
                        captureAutomationConfiguration.ReadXml(reader);
                        break;
                    case "HighspeedRecordingFramerateThreshold":
                        string hrft = reader.ReadElementContentreplacedtring();
                        highspeedRecordingFramerateThreshold = float.Parse(hrft, CultureInfo.InvariantCulture);
                        break;
                    case "HighspeedRecordingFramerateOutput":
                        string hrfo = reader.ReadElementContentreplacedtring();
                        highspeedRecordingFramerateOutput = float.Parse(hrfo, CultureInfo.InvariantCulture);
                        break;
                    case "SlowspeedRecordingFramerateThreshold":
                        string srft = reader.ReadElementContentreplacedtring();
                        slowspeedRecordingFramerateThreshold = float.Parse(srft, CultureInfo.InvariantCulture);
                        break;
                    case "SlowspeedRecordingFramerateOutput":
                        string srfo = reader.ReadElementContentreplacedtring();
                        slowspeedRecordingFramerateOutput = float.Parse(srfo, CultureInfo.InvariantCulture);
                        break;
                    case "PostRecordCommand":
                        postRecordCommand = reader.ReadElementContentreplacedtring();
                        break;
                    case "CaptureKVA":
                        captureKVA = reader.ReadElementContentreplacedtring();
                        break;
                    default:
                        reader.ReadOuterXml();
                        break;
                }
            }
            
            reader.ReadEndElement();
        }

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

public void ReadXML(XmlReader reader)
        {
            reader.ReadStartElement();

            while(reader.NodeType == XmlNodeType.Element)
            {
                switch(reader.Name)
                {
                    case "MaxRecentFiles":
                        maxRecentFiles = reader.ReadElementContentAsInt();
                        break;
                    case "RecentFiles":
                        ParseRecentFiles(reader, recentFiles, "RecentFile");
                        break;
                    case "Recenreplacedchers":
                        ParseRecentFiles(reader, recenreplacedchers, "Recenreplacedcher");
                        break;
                    case "MaxRecentCapturedFiles":
                        maxRecentCapturedFiles = reader.ReadElementContentAsInt();
                        break;
                    case "RecentCapturedFiles":
                        ParseRecentFiles(reader, recentCapturedFiles, "RecentCapturedFile");
                        break;
                    case "Shortcuts":
                        ParseShortcuts(reader);
                        break;
                    case "ThumbnailSize":
                        explorerThumbsSize = (ExplorerThumbSize) Enum.Parse(typeof(ExplorerThumbSize), reader.ReadElementContentreplacedtring());
                        break;
                    case "ExplorerFilesSplitterDistance":
                        explorerFilesSplitterDistance = reader.ReadElementContentAsInt();
                        break;
                    case "ShortcutsFilesSplitterDistance":
                        shortcutsFilesSplitterDistance = reader.ReadElementContentAsInt();
                        break;                        
                    case "ActiveTab":
                        activeTab = (ActiveFileBrowserTab) Enum.Parse(typeof(ActiveFileBrowserTab), reader.ReadElementContentreplacedtring());
                        break;
                    case "FilePropertyVisibility":
                        filePropertyVisibility = FilePropertyVisibility.FromXML(reader);
                        break;
                    case "LastReplayFolder":
                        lastReplayFolder = reader.ReadElementContentreplacedtring();
                        break;
                    default:
                        reader.ReadOuterXml();
                        break;
                }
            }
            
            reader.ReadEndElement();
        }

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

public void ReadXML(XmlReader reader)
        {
            reader.ReadStartElement();

            while (reader.NodeType == XmlNodeType.Element)
            {
                switch (reader.Name)
                {
                    case "Culture":
                        uiCultureName = reader.ReadElementContentreplacedtring();
                        break;
                    case "ExplorerVisible":
                        explorerVisible = XmlHelper.ParseBoolean(reader.ReadElementContentreplacedtring());
                        break;
                    case "ExplorerSplitterDistance":
                        explorerSplitterDistance = reader.ReadElementContentAsInt();
                        break;
                    case "WindowState":
                        windowState = (FormWindowState)Enum.Parse(typeof(FormWindowState), reader.ReadElementContentreplacedtring());
                        break;
                    case "WindowRectangle":
                        windowRectangle = XmlHelper.ParseRectangle(reader.ReadElementContentreplacedtring());
                        break;
                    case "Workspace":
                        workspace.ReadXML(reader);
                        break;
                    case "AllowMultipleInstances":
                        allowMultipleInstances = XmlHelper.ParseBoolean(reader.ReadElementContentreplacedtring());
                        break;
                    case "InstancesOwnPreferences":
                        instancesOwnPreferences = XmlHelper.ParseBoolean(reader.ReadElementContentreplacedtring());
                        break;
                    case "PreferencesPage":
                        preferencePage = reader.ReadElementContentAsInt();
                        break;
                    default:
                        reader.ReadOuterXml();
                        break;
                }
            }

            reader.ReadEndElement();
        }

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

public void ReadXML(XmlReader reader)
        {
            reader.ReadStartElement();

            while(reader.NodeType == XmlNodeType.Element)
            {
                switch(reader.Name)
                {
                    case "TimecodeFormat":
                        timecodeFormat = (TimecodeFormat) Enum.Parse(typeof(TimecodeFormat), reader.ReadElementContentreplacedtring());
                        break;
                    case "SpeedUnit":
                        speedUnit = (SpeedUnit) Enum.Parse(typeof(SpeedUnit), reader.ReadElementContentreplacedtring());
                        break;
                    case "AccelerationUnit":
                        accelerationUnit = (AccelerationUnit)Enum.Parse(typeof(AccelerationUnit), reader.ReadElementContentreplacedtring());
                        break;
                    case "AngleUnit":
                        angleUnit = (AngleUnit)Enum.Parse(typeof(AngleUnit), reader.ReadElementContentreplacedtring());
                        break;
                    case "AngularVelocityUnit":
                        angularVelocityUnit = (AngularVelocityUnit)Enum.Parse(typeof(AngularVelocityUnit), reader.ReadElementContentreplacedtring());
                        break;
                    case "AngularAccelerationUnit":
                        angularAccelerationUnit = (AngularAccelerationUnit)Enum.Parse(typeof(AngularAccelerationUnit), reader.ReadElementContentreplacedtring());
                        break;
                    case "CustomLengthUnit":
                        customLengthUnit = reader.ReadElementContentreplacedtring();
                        break;
                    case "CustomLengthAbbreviation":
                        customLengthAbbreviation = reader.ReadElementContentreplacedtring();
                        break;
                    case "AspectRatio":
                        aspectRatio = (ImageAspectRatio) Enum.Parse(typeof(ImageAspectRatio), reader.ReadElementContentreplacedtring());
                        break;
                    case "DeinterlaceByDefault":
                        deinterlaceByDefault = XmlHelper.ParseBoolean(reader.ReadElementContentreplacedtring());
                        break;
                    case "InteractiveFrameTracker":
                        interactiveFrameTracker = XmlHelper.ParseBoolean(reader.ReadElementContentreplacedtring());
                        break;
                    case "WorkingZoneMemory":
                        workingZoneMemory = reader.ReadElementContentAsInt();
                        break;
                    case "SyncLockSpeed":
                        syncLockSpeed = XmlHelper.ParseBoolean(reader.ReadElementContentreplacedtring());
                        break;
                    case "SyncByMotion":
                        syncByMotion = XmlHelper.ParseBoolean(reader.ReadElementContentreplacedtring());
                        break;
                    case "ImageFormat":
                        imageFormat = (KinoveaImageFormat)Enum.Parse(typeof(KinoveaImageFormat), reader.ReadElementContentreplacedtring());
                        break;
                    case "VideoFormat":
                        videoFormat = (KinoveaVideoFormat)Enum.Parse(typeof(KinoveaVideoFormat), reader.ReadElementContentreplacedtring());
                        break;
                    case "Background":
                        backgroundColor = XmlHelper.ParseColor(reader.ReadElementContentreplacedtring(), defaultBackgroundColor);
                        break;
                    case "InfoFading":
                        defaultFading.ReadXml(reader);
                        break;
                    case "DrawOnPlay":
                        drawOnPlay = XmlHelper.ParseBoolean(reader.ReadElementContentreplacedtring());
                        break;                        
                    case "RecentColors":
                        ParseRecentColors(reader);
                        break;
                    case "MaxRecentColors":
                        maxRecentColors = reader.ReadElementContentAsInt();
                        break;
                    case "TrackingProfile":
                        trackingProfile.ReadXml(reader);
                        break;
                    case "EnableFiltering":
                        enableFiltering = XmlHelper.ParseBoolean(reader.ReadElementContentreplacedtring());
                        break;
                    case "EnableCustomToolsDebugMode":
                        enableCustomToolsDebugMode = XmlHelper.ParseBoolean(reader.ReadElementContentreplacedtring());
                        break;
                    case "DefaultReplaySpeed":
                        string str = reader.ReadElementContentreplacedtring();
                        defaultReplaySpeed = float.Parse(str, CultureInfo.InvariantCulture);
                        break;
                    case "DetectImageSequences":
                        detectImageSequences = XmlHelper.ParseBoolean(reader.ReadElementContentreplacedtring());
                        break;
                    case "PreloadKeyframes":
                        preloadKeyframes = reader.ReadElementContentAsInt();
                        break;
                    case "PlaybackKVA":
                        playbackKVA = reader.ReadElementContentreplacedtring();
                        break;
                    default:
                        reader.ReadOuterXml();
                        break;
                }
            }
            
            reader.ReadEndElement();
        }

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

public void ReadXml(XmlReader xmlReader)
        {
            xmlReader.ReadStartElement();
            
            while(xmlReader.NodeType == XmlNodeType.Element)
            {
                switch(xmlReader.Name)
                {
                    case "Enabled":
                        enabled = XmlHelper.ParseBoolean(xmlReader.ReadElementContentreplacedtring());
                        break;
                    case "UseDefault":
                        useDefault = XmlHelper.ParseBoolean(xmlReader.ReadElementContentreplacedtring());
                        break;
                    case "AlwaysVisible":
                        alwaysVisible = XmlHelper.ParseBoolean(xmlReader.ReadElementContentreplacedtring());
                        break;
                    case "MasterFactor":
                        masterFactor = float.Parse(xmlReader.ReadElementContentreplacedtring(), CultureInfo.InvariantCulture);
                        break;
                    case "OpaqueFrames":
                        opaqueFrames = xmlReader.ReadElementContentAsInt();
                        break;
                    case "Frames":
                        fadingFrames = xmlReader.ReadElementContentAsInt();
                        break;
                    default:
                        string unparsed = xmlReader.ReadOuterXml();
                        log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
                        break;
                }
            }
            
            xmlReader.ReadEndElement();

            fadingFrames = Math.Max(fadingFrames, 1);
        }

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

private static SyntheticVideo Parse(XmlReader r)
        {
            SyntheticVideo video = new SyntheticVideo();

            r.MoveToContent();

            if (!(r.Name == "KinoveaSyntheticVideo"))
                return video;

            r.ReadStartElement();
            r.ReadElementContentreplacedtring("FormatVersion", "");

            while (r.NodeType == XmlNodeType.Element)
            {
                switch (r.Name)
                {
                    case "ImageSize":
                        video.ImageSize = XmlHelper.ParseSize(r.ReadElementContentreplacedtring());
                        break;
                    case "FramesPerSecond":
                        video.FramePerSecond = r.ReadElementContentAsDouble();
                        break;
                    case "DurationFrames":
                        video.DurationFrames = r.ReadElementContentAsInt();
                        break;
                    case "BackgroundColor":
                        video.BackgroundColor = XmlHelper.ParseColor(r.ReadElementContentreplacedtring(), Color.White);
                        break;
                    case "FrameNumber":
                        video.FrameNumber = XmlHelper.ParseBoolean(r.ReadElementContentreplacedtring());
                        break;
                    case "Objects":
                        video.Objects = ParseObjects(r);
                        break;
                    default:
                        // Skip unparsed nodes.
                        string unparsed = r.ReadOuterXml();
                        log.DebugFormat("Unparsed content in KSV XML: {0}", unparsed);
                        break;
                }
            }

            r.ReadEndElement();

            return video;
        }

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

private static SyntheticObject ParseObject(XmlReader r)
        {
            int radius = 0;
            PointF position = PointF.Empty;
            double vx = 0;
            double vy = 0;
            double ax = 0;
            double ay = 0;

            r.ReadStartElement();

            while (r.NodeType == XmlNodeType.Element)
            {
                switch(r.Name)
                {
                    case "Radius":
                        radius = r.ReadElementContentAsInt();
                        break;
                    case "Position":
                        position = XmlHelper.ParsePointF(r.ReadElementContentreplacedtring());
                        break;
                    case "Velocity":
                        PointF v = XmlHelper.ParsePointF(r.ReadElementContentreplacedtring());
                        vx = v.X;
                        vy = v.Y;
                        break;
                    case "Acceleration":
                        PointF a = XmlHelper.ParsePointF(r.ReadElementContentreplacedtring());
                        ax = a.X;
                        ay = a.Y;
                        break;
                    default:
                        string unparsed = r.ReadOuterXml();
                        log.DebugFormat("Unparsed content in KSV synthetic object: {0}", unparsed);
                        break;
                }
            }

            r.ReadEndElement();
            
            return radius != 0 ? new SyntheticObject(radius, position, vx, vy, ax, ay) : null;
        }

19 Source : GraphReader.cs
with GNU General Public License v2.0
from league1991

private int ReadElementContentAsInt() {
            return xmlReader.ReadElementContentAsInt();
        }

19 Source : HaarFeature.cs
with MIT License
from PacktPublishing

void IXmlSerializable.ReadXml(XmlReader reader)
        {
            reader.ReadStartElement("feature");

            reader.ReadToFollowing("rects");
            reader.ReadToFollowing("_");

            var rec = new List<HaarRectangle>();
            while (reader.Name == "_")
            {
                string str = reader.ReadElementContentreplacedtring();
                rec.Add(HaarRectangle.Parse(str));

                while (reader.Name != "_" && reader.Name != "tilted" &&
                    reader.NodeType != XmlNodeType.EndElement)
                    reader.Read();
            }

            Rectangles = rec.ToArray();

            reader.ReadToFollowing("tilted", reader.BaseURI);
            Tilted = reader.ReadElementContentAsInt() == 1;

            reader.ReadEndElement();
        }