示例#1
0
文件: BBC.cs 项目: YAAnon/YAAB
    public static void bbc(string[] command)
    {
        string pageToRetrieve = "", retrievedPage;

        if (command.Length != 2)
        {
            BaseFunctions.message("Possible combinations are: \"?bbc \" + (\"tech\" | \"world\" | \"top\" | \"sci\")");
            return;
        }

        switch (command[1])
        {
            case "tech":
                pageToRetrieve = "http://feeds.bbci.co.uk/news/technology/rss.xml";
                break;

            case "sci":
                pageToRetrieve = "http://feeds.bbci.co.uk/news/science_and_environment/rss.xml";
                break;

            case "world":
                pageToRetrieve = "http://feeds.bbci.co.uk/news/world/rss.xml";
                break;

            case "top":
                pageToRetrieve = "http://feeds.bbci.co.uk/news/rss.xml";
                break;
        }

        if(pageToRetrieve == "")
            BaseFunctions.message("Bad command - possible combinations are: \"?bbc \" + (\"tech\" | \"world\" | \"top\" | \"sci\")");

        retrievedPage = fetchUrl(pageToRetrieve);

        xmlReader = XmlReader.Create(new StringReader(retrievedPage)); // create xmlreader to parse the page
        Console.WriteLine("got xml data");

        xmlReader.ReadToFollowing("title"); //the BBC put two title's in their rss feeds, so this skips one

        BaseFunctions.message(returnContent("title"));

        for (int i = 0; i < 3; i++)
        {
            string message;
            message = "--- " + returnContent("title") + " - " + returnContent("guid");

            BaseFunctions.message(message);

            System.Threading.Thread.Sleep(50);
        }
    }
示例#2
0
        private void ReadSheetGlobals(XlsxWorksheet sheet)
        {
            if (_xmlReader != null)
            {
                _xmlReader.Close();
            }
            if (_sheetStream != null)
            {
                _sheetStream.Close();
            }

            _sheetStream = _zipWorker.GetWorksheetStream(sheet.Path);

            if (null == _sheetStream)
            {
                return;
            }

            _xmlReader = XmlReader.Create(_sheetStream);

            //count rows and cols in case there is no dimension elements
            int rows = 0;
            int cols = 0;

            _namespaceUri = null;
            int biggestColumn = 0;         //used when no col elements and no dimension

            while (_xmlReader.Read())
            {
                if (_xmlReader.NodeType == XmlNodeType.Element && _xmlReader.LocalName == XlsxWorksheet.N_worksheet)
                {
                    //grab the namespaceuri from the worksheet element
                    _namespaceUri = _xmlReader.NamespaceURI;
                }

                if (_xmlReader.NodeType == XmlNodeType.Element && _xmlReader.LocalName == XlsxWorksheet.N_dimension)
                {
                    string dimValue = _xmlReader.GetAttribute(XlsxWorksheet.A_ref);

                    sheet.Dimension = new XlsxDimension(dimValue);
                    break;
                }

                //removed: Do not use col to work out number of columns as this is really for defining formatting, so may not contain all columns
                //if (_xmlReader.NodeType == XmlNodeType.Element && _xmlReader.LocalName == XlsxWorksheet.N_col)
                //    cols++;

                if (_xmlReader.NodeType == XmlNodeType.Element && _xmlReader.LocalName == XlsxWorksheet.N_row)
                {
                    rows++;
                }

                //check cells so we can find size of sheet if can't work it out from dimension or col elements (dimension should have been set before the cells if it was available)
                //ditto for cols
                if (sheet.Dimension == null && cols == 0 && _xmlReader.NodeType == XmlNodeType.Element && _xmlReader.LocalName == XlsxWorksheet.N_c)
                {
                    var refAttribute = _xmlReader.GetAttribute(XlsxWorksheet.A_r);

                    if (refAttribute != null)
                    {
                        var thisRef = ReferenceHelper.ReferenceToColumnAndRow(refAttribute);
                        if (thisRef[1] > biggestColumn)
                        {
                            biggestColumn = thisRef[1];
                        }
                    }
                }
            }


            //if we didn't get a dimension element then use the calculated rows/cols to create it
            if (sheet.Dimension == null)
            {
                if (cols == 0)
                {
                    cols = biggestColumn;
                }

                if (rows == 0 || cols == 0)
                {
                    sheet.IsEmpty = true;
                    return;
                }

                sheet.Dimension = new XlsxDimension(rows, cols);

                //we need to reset our position to sheet data
                _xmlReader.Close();
                _sheetStream.Close();
                _sheetStream = _zipWorker.GetWorksheetStream(sheet.Path);
                _xmlReader   = XmlReader.Create(_sheetStream);
            }

            //read up to the sheetData element. if this element is empty then there aren't any rows and we need to null out dimension

            _xmlReader.ReadToFollowing(XlsxWorksheet.N_sheetData, _namespaceUri);
            if (_xmlReader.IsEmptyElement)
            {
                sheet.IsEmpty = true;
            }
        }
示例#3
0
        /// <summary>
        /// Loads a settings file to set server variables to be used for computation.
        /// </summary>
        /// <param name="filePath">The location of the settings file.</param>
        private void Load(string filePath)
        {
            string   currentLine;
            int      wallStart;
            int      WallEnd;
            int      tempx;
            int      tempy;
            int      wallID = 0;
            Vector2D wallLocation;

            //Wall walltoAdd = new Wall();
            try
            {
                using (XmlReader reader = XmlReader.Create(filePath))
                {
                    while (reader.Read())
                    {
                        if (reader.IsStartElement())
                        {
                            currentLine = reader.Name;
                            switch (currentLine)
                            {
                            case "UniverseSize":
                                worldSize = reader.ReadElementContentAsInt();
                                break;

                            case "MSPerFrame":
                                FPS = reader.ReadElementContentAsInt();
                                break;

                            case "FramesPerShot":
                                shotDelay = reader.ReadElementContentAsInt();
                                break;

                            case "RespawnRate":
                                respawnTime = reader.ReadElementContentAsInt();
                                break;

                            case "HitPoints":
                                playerHP = reader.ReadElementContentAsInt();
                                break;

                            case "TankSpeed":
                                playerSpeed = reader.ReadElementContentAsDouble();
                                break;

                            case "TankSize":
                                playerSize = reader.ReadElementContentAsInt();
                                break;

                            case "WallSize":
                                wallSize = reader.ReadElementContentAsInt();
                                break;

                            case "MaxPowerups":
                                powerupCount = reader.ReadElementContentAsInt();
                                break;

                            case "MaxPowerupDelay":
                                maxPowerupSpawnTime = reader.ReadElementContentAsInt();
                                break;

                            case "Wall":
                                Wall walltoAdd = new Wall();
                                reader.ReadToDescendant("p1");
                                //set x for wall start
                                reader.ReadToFollowing("x");
                                tempx = int.Parse(reader.ReadInnerXml());
                                //set y for wall start
                                reader.ReadToFollowing("y");
                                tempy = int.Parse(reader.ReadInnerXml());
                                //set start location
                                wallLocation = new Vector2D(tempx, tempy);
                                walltoAdd.SetStartLocation(wallLocation);
                                reader.ReadToNextSibling("p2");
                                //set x for wall end
                                reader.ReadToFollowing("x");
                                tempx = int.Parse(reader.ReadInnerXml());
                                //set y for wall end
                                reader.ReadToFollowing("y");
                                tempy = int.Parse(reader.ReadInnerXml());
                                //set end location
                                wallLocation = new Vector2D(tempx, tempy);
                                walltoAdd.SetEndLocation(wallLocation);
                                walltoAdd.SetID(wallID);
                                lock (world)
                                {
                                    world.AddObject(wallID, walltoAdd);
                                }
                                wallID++;
                                break;

                            default:
                                break;
                            }
                        }
                    }
                }
            }
            catch (FileNotFoundException)
            {
                throw new FileNotFoundException("Could not load file.");
            }
            catch (DirectoryNotFoundException)
            {
                throw new DirectoryNotFoundException("Could not find file path.");
            }
            catch (XmlException)
            {
                throw new XmlException("File data not readable.");
            }
        }
 public override bool ReadToFollowing(string localName, string namespaceURI)
 {
     IncrementCount();
     return(innerReader.ReadToFollowing(localName, namespaceURI));
 }
示例#5
0
        /// <summary>
        /// Import a storyboard given a full path to the storyboard bmp. The XML file for
        /// the storyboard must have a matching filename with the XML extension, and be in
        /// the same directory.
        /// </summary>
        /// <param name="Filename"></param>
        /// <returns></returns>
        public bool ImportStoryboard(string Filename)
        {
            string path = Path.GetDirectoryName(Filename);
            // raw filename without path or extensions
            string xmlFilename = Path.GetFileNameWithoutExtension(Filename);

            // index for reading bmp data, incremented as we split the giant bmp
            uint readoffset = 0;

            // open bmp into one giant bitmap
            Bitmap bmp         = (Bitmap)Image.FromFile(Filename);
            uint   totalWidth  = (uint)bmp.Width;
            uint   totalHeight = (uint)bmp.Height;

            byte[] pixelData = BgfBitmap.BitmapToPixelData(bmp);

            // cleanp temporary bitmap
            bmp.Dispose();

            // init XML reader
            XmlReader reader = XmlReader.Create(Path.Combine(path, xmlFilename) + FileExtensions.XML);

            // read in xml file
            // rootnode
            reader.ReadToFollowing("bgf");
            uint version = Convert.ToUInt32(reader["version"]);

            if (version >= BgfFile.VERSION9)
            {
                ShrinkFactor = Convert.ToUInt32(reader["shrink"]);

                // skip maxindices, we use dynamic getter
                // MaxIndices = Convert.ToUInt32(reader["maxindices"]);

                // frames
                reader.ReadToFollowing("frames");
                int  FrameCount       = Convert.ToInt32(reader["count"]);
                uint savedTotalHeight = Convert.ToUInt32(reader["totalheight"]);
                uint savedTotalWidth  = Convert.ToUInt32(reader["totalwidth"]);
                // Saved dimensions must match those loaded for the storyboard bmp.
                if (savedTotalWidth != totalWidth || savedTotalHeight != totalHeight)
                {
                    return(false);
                }

                Frames.Capacity = FrameCount;
                for (int i = 0; i < FrameCount; i++)
                {
                    reader.ReadToFollowing("frame");
                    uint width   = Convert.ToUInt32(reader["width"]);
                    uint height  = Convert.ToUInt32(reader["height"]);
                    int  xoffset = Convert.ToInt32(reader["xoffset"]);
                    int  yoffset = Convert.ToInt32(reader["yoffset"]);

                    // hotspots
                    reader.ReadToFollowing("hotspots");
                    byte hotspotcount = Convert.ToByte(reader["count"]);
                    List <BgfBitmapHotspot> hotspots = new List <BgfBitmapHotspot>(hotspotcount);
                    for (int j = 0; j < hotspotcount; j++)
                    {
                        reader.ReadToFollowing("hotspot");
                        sbyte index = Convert.ToSByte(reader["index"]);
                        int   x     = Convert.ToInt32(reader["x"]);
                        int   y     = Convert.ToInt32(reader["y"]);

                        BgfBitmapHotspot hotspot = new BgfBitmapHotspot(index, x, y);
                        hotspots.Add(hotspot);
                    }

                    // get pixels for this frame from the single bmp
                    byte[] pixels      = new byte[height * width];
                    uint   writeoffset = 0;
                    for (int j = 0; j < height; ++j)
                    {
                        Wrapper.CopyMem(pixelData, (int)readoffset, pixels, (int)writeoffset, width);
                        readoffset  += totalWidth;
                        writeoffset += width;
                    }

                    BgfBitmap bgfBitmap = new BgfBitmap(
                        (uint)i + 1,
                        version,
                        width,
                        height,
                        xoffset,
                        yoffset,
                        hotspots,
                        false,
                        0,
                        pixels);

                    Frames.Add(bgfBitmap);
                }

                // framesets
                reader.ReadToFollowing("framesets");
                int FrameSetCount = Convert.ToInt32(reader["count"]);
                FrameSets.Capacity = FrameSetCount;
                for (int i = 0; i < FrameSetCount; i++)
                {
                    reader.ReadToFollowing("frameset");
                    string[]   indices    = reader["indices"].Split(' ');
                    List <int> intIndices = new List <int>();
                    foreach (string index in indices)
                    {
                        intIndices.Add(Convert.ToInt32(index));
                    }

                    BgfFrameSet bgfFrameSet = new BgfFrameSet((uint)i + 1, intIndices);

                    FrameSets.Add(bgfFrameSet);
                }
            }
            else
            {
                throw new Exception("Wrong format version: " + version + " (expected " + BgfFile.VERSION9 + ").");
            }

            return(true);
        }
示例#6
0
        private void dataGridView1_RowEnter(object sender, DataGridViewCellEventArgs e)
        {
            try
            {
                // number the coloums
                int a = -1;
                foreach (DataGridViewColumn col in dataGridView1.Columns)
                {
                    col.HeaderText = a.ToString();
                    a++;
                }
            }
            catch { }
            try
            {
                // process the line type
                string option = dataGridView1[1, e.RowIndex].EditedFormattedValue.ToString();

                // new self describing log
                if (logformat.ContainsKey(option))
                {
                    int a = 2;
                    foreach (string name in logformat[option].FieldNames)
                    {
                        dataGridView1.Columns[a].HeaderText = name;
                        a++;
                    }
                    for (; a < dataGridView1.Columns.Count; a++)
                    {
                        dataGridView1.Columns[a].HeaderText = "";
                    }
                    return;
                }

                if (option.StartsWith("PID-"))
                {
                    option = "PID-1";
                }

                using (XmlReader reader = XmlReader.Create(Path.GetDirectoryName(Application.ExecutablePath) + Path.DirectorySeparatorChar + "dataflashlog.xml"))
                {
                    reader.Read();
                    reader.ReadStartElement("LOGFORMAT");
                    if (MainV2.comPort.MAV.cs.firmware == MainV2.Firmwares.ArduPlane)
                    {
                        reader.ReadToFollowing("APM");
                    }
                    else if (MainV2.comPort.MAV.cs.firmware == MainV2.Firmwares.ArduRover)
                    {
                        reader.ReadToFollowing("APRover");
                    }
                    else
                    {
                        reader.ReadToFollowing("AC2");
                    }
                    reader.ReadToFollowing(option);

                    dataGridView1.Columns[1].HeaderText = "";

                    if (reader.NodeType == XmlNodeType.None)
                    {
                        return;
                    }

                    XmlReader inner = reader.ReadSubtree();

                    inner.MoveToElement();

                    int a = 2;

                    while (inner.Read())
                    {
                        inner.MoveToElement();
                        if (inner.IsStartElement())
                        {
                            if (inner.Name.StartsWith("F"))
                            {
                                dataGridView1.Columns[a].HeaderText = inner.ReadString();
                                log.Info(a + " " + dataGridView1.Columns[a].HeaderText);
                                a++;
                            }
                        }
                    }

                    for (; a < dataGridView1.Columns.Count; a++)
                    {
                        dataGridView1.Columns[a].HeaderText = "";
                    }
                }
            }
            catch { log.Info("DGV logbrowse error"); }
        }
        public static analysis Results(string xmlfile)
        {
            analysis answer = new analysis();

            using (XmlReader reader = XmlReader.Create(xmlfile))
            {
                while (!reader.EOF)
                {
                    if (reader.ReadToFollowing("header"))
                    {
                        var subtree = reader.ReadSubtree();

                        while (subtree.Read())
                        {
                            subtree.MoveToElement();
                            if (subtree.IsStartElement())
                            {
                                try
                                {
                                    switch (subtree.Name.ToLower())
                                    {
                                    case "logfile":
                                        answer.logfile = subtree.ReadString();
                                        break;

                                    case "sizekb":
                                        answer.sizekb = subtree.ReadString();
                                        break;

                                    case "sizelines":
                                        answer.sizelines = subtree.ReadString();
                                        break;

                                    case "duration":
                                        answer.duration = subtree.ReadString();
                                        break;

                                    case "vehicletype":
                                        answer.vehicletype = subtree.ReadString();
                                        break;

                                    case "firmwareversion":
                                        answer.firmwareversion = subtree.ReadString();
                                        break;

                                    case "firmwarehash":
                                        answer.firmwarehash = subtree.ReadString();
                                        break;

                                    case "hardwaretype":
                                        answer.hardwaretype = subtree.ReadString();
                                        break;

                                    case "freemem":
                                        answer.freemem = subtree.ReadString();
                                        break;

                                    case "skippedlines":
                                        answer.skippedlines = subtree.ReadString();
                                        break;
                                    }
                                }
                                catch (Exception ex)
                                {
                                    log.Error(ex);
                                }
                            }
                        }
                    }
                    // params - later
                    if (reader.ReadToFollowing("results"))
                    {
                        var subtree = reader.ReadSubtree();

                        result res = null;

                        while (subtree.Read())
                        {
                            subtree.MoveToElement();
                            if (subtree.IsStartElement())
                            {
                                switch (subtree.Name.ToLower())
                                {
                                case "result":
                                    if (res != null && res.name != "")
                                    {
                                        answer.results.Add(res);
                                    }
                                    res = new result();
                                    break;

                                case "name":
                                    res.name = subtree.ReadString();
                                    break;

                                case "status":
                                    res.status = subtree.ReadString();
                                    break;

                                case "message":
                                    res.message = subtree.ReadString();
                                    break;

                                case "data":
                                    res.data = subtree.ReadString();
                                    break;
                                }
                            }
                        }
                    }
                }
            }

            return(answer);
        }
示例#8
0
    private static int[][][] loadSpriteLayer(XmlReader mapReader, int levelNum)
    {
        int[][][] layer;

        int width = Int32.Parse(mapReader[1]);
        int height = Int32.Parse(mapReader[2]);

        layer = new int[height][][];
        for (int i = 0; i < height; i++) {
            layer[i] = new int[width][];
            for (int j = 0; j < width; j++) {
                layer[i][j] = new int[4];
            }
        }

        for (int i = 0; i < height * width; i++) {
            mapReader.ReadToFollowing("tile");
            uint val = UInt32.Parse(mapReader[0]);
            int sprite = 0;

            int xflip = 0;
            xflip = (int)(val & (1 << 31));
            if (xflip != 0) {
                xflip = 1;

                if (sprite != 0) {
                    sprite = (int)sprite & ~(1 << 31);
                } else {
                    sprite = (int)val & ~(1 << 31);
                }
            }

            int yflip = 0;
            yflip = (int)(val & (1 << 30));
            if (yflip != 0) {
                yflip = 1;
                if (sprite != 0) {
                    sprite = (int)sprite & ~(1 << 30);
                } else {
                    sprite = (int)val & ~(1 << 30);
                }
            }

            int rotate = 0;
            rotate = (int)(val & (1 << 29));
            if (rotate != 0) {
                rotate = 1;
                if (sprite != 0) {
                    sprite = (int)sprite & ~(1 << 29);
                } else {
                    sprite = (int)val & ~(1 << 29);
                }
            }

            if (sprite == 0) {
                sprite = (int)val;
            }

            layer[i / width][i % width][0] = sprite;
            layer[i / width][i % width][1] = xflip;
            layer[i / width][i % width][2] = yflip;
            layer[i / width][i % width][3] = rotate;
        }
        return layer;
    }
示例#9
0
    private ItemConsume LoadConsumeItem(XmlReader xmlReader, int id)
    {
        ItemConsume itemConsume = new ItemConsume(id, xmlReader.GetAttribute("name"));

        xmlReader.ReadToDescendant("description"); //<description>
        itemConsume.description = xmlReader.ReadElementContentAsString();

        //<icon path=.../>
        if (xmlReader.ReadToNextSibling("icon") && xmlReader.GetAttribute(0) != "")
        {
            itemConsume.iconPath = xmlReader.GetAttribute(0);
        }
        else
        {
            itemConsume.iconPath = defaultSpritePath;
        }

        //<model path=.../>
        if (xmlReader.ReadToNextSibling("model") && xmlReader.GetAttribute(0) != "")
        {
            itemConsume.dropModelPath = xmlReader.GetAttribute(0);
        }
        else
        {
            itemConsume.dropModelPath = defaultDropModelPath;
        }

        if (xmlReader.ReadToNextSibling("salePrice")) //<salePrice>..</salePrice>
        {
            itemConsume.salePrice = xmlReader.ReadElementContentAsInt();
        }
        else
        {
            itemConsume.salePrice = 0;
        }

        if (xmlReader.ReadToFollowing("numberTicks")) //<numberTicks>
        {
            itemConsume.numberTicks = xmlReader.ReadElementContentAsInt();
        }
        else
        {
            itemConsume.numberTicks = 1;
        }

        if (xmlReader.ReadToFollowing("delayTick")) //<delayTick>
        {
            itemConsume.delayTick = xmlReader.ReadElementContentAsFloat();
        }
        else
        {
            itemConsume.delayTick = 1.0f;
        }

        if (xmlReader.ReadToFollowing("maxInStack")) //<maxInStack>
        {
            itemConsume.maxInStack = xmlReader.ReadElementContentAsInt();
        }
        else
        {
            itemConsume.maxInStack = 99;
        }

        //<atributes>
        if (xmlReader.ReadToNextSibling("atributes") && xmlReader.ReadToDescendant("add"))//<add..
        {
            AtributeTypeItem tempType;
            float            tempValue;
            do
            {
                tempType  = (AtributeTypeItem)System.Enum.Parse(typeof(AtributeTypeItem), xmlReader.GetAttribute(0));
                tempValue = xmlReader.ReadElementContentAsFloat();
                itemConsume.itemAttributes.Add(new AttributeItem(tempType, tempValue));
            } while (xmlReader.ReadToNextSibling("add"));
        }

        xmlReader.Close();
        return(itemConsume);
    }
示例#10
0
        public static async Task FetchImageResponse(ObservableCollection <GameData> gamelist)
        {
            HttpResponseMessage response = null;

            foreach (var game in gamelist)
            {
                queue.Enqueue(game);
            }

            while (queue.Count != 0)
            {
                var game = queue.Dequeue();

                if (game.GameCoverCacheImage == null || game.GameCoverCacheImage.UriSource == null)
                {
                    if (imageURLcollection.ContainsKey(game.GameID) &&
                        imageURLcollection[game.GameID] as HttpResponseMessage != null)
                    {
                        response = imageURLcollection[game.GameID];
                    }

                    else
                    {
                        try
                        {
                            response = await client.GetAsync("http://thegamesdb.net/api/GetArt.php?id=" + game.GameID, HttpCompletionOption.ResponseHeadersRead);
                        }

                        catch (TaskCanceledException e)
                        {
                            if (!e.CancellationToken.IsCancellationRequested)
                            {
                                //request timed out
                            }
                        }

                        if (imageURLcollection.ContainsKey(game.GameID))
                        {
                            imageURLcollection[game.GameID] = response;
                        }

                        else
                        {
                            imageURLcollection.Add(game.GameID, response);
                        }
                    }



                    if (response != null && response.IsSuccessStatusCode)
                    {
                        //Read through image page

                        string imageXML = await response.Content.ReadAsStringAsync();

                        using (XmlReader imageReader = XmlReader.Create(new StringReader(imageXML)))
                        {
                            imageReader.ReadToFollowing("baseImgUrl");
                            imageReader.Read();
                            string imageURL = imageReader.Value;

                            imageReader.ReadToFollowing("boxart");
                            imageReader.MoveToFirstAttribute();
                            imageReader.ReadAttributeValue();

                            if (imageReader.Value == "front")
                            {
                                imageReader.Read();
                                imageURL += imageReader.Value;

                                var bitmap = new BitmapImage()
                                {
                                    CreateOptions = BitmapCreateOptions.None
                                };
                                bitmap.DecodePixelHeight = 99;
                                bitmap.DecodePixelWidth  = 99;
                                bitmap.UriSource         = new Uri(imageURL);

                                game.GameCoverCacheImage = bitmap;

                                bitmap = null;
                            }

                            else
                            {
                                if (imageReader.ReadToFollowing("boxart"))
                                {
                                    imageReader.MoveToFirstAttribute();
                                    imageReader.ReadAttributeValue();
                                    imageReader.Read();
                                    imageURL += imageReader.Value;

                                    var bitmap = new BitmapImage()
                                    {
                                        CreateOptions = BitmapCreateOptions.None
                                    };
                                    bitmap.DecodePixelHeight = 99;
                                    bitmap.DecodePixelWidth  = 99;
                                    bitmap.UriSource         = new Uri(imageURL);

                                    game.GameCoverCacheImage = bitmap;

                                    bitmap = null;
                                }

                                else
                                {
                                    imageURL = String.Empty;
                                }
                            }

                            imageURL = String.Empty;
                        }
                    }
                }
            }

            client.CancelPendingRequests();
        }
示例#11
0
        public static void FormSearchResultsList()
        {
            //Using the XMLData, form a list of 10 game data on the page
            using (XmlReader reader = XmlReader.Create(new StringReader(XMLData)))
            {
                string title       = String.Empty;
                int    gameID      = 0;
                string imageURL    = String.Empty;
                string releaseDate = String.Empty;
                string console     = String.Empty;
                string imageXML    = String.Empty;

                for (int i = 0; i < 20; ++i)
                {
                    if (reader.ReadToFollowing("id"))
                    {
                        reader.Read();

                        try
                        {
                            gameID = int.Parse(reader.Value);
                        }

                        catch (Exception)
                        {
                            //do something here later
                            gameID = 0;
                            continue;
                        }
                    }

                    else
                    {
                        break;
                    }


                    reader.ReadToFollowing("GameTitle");
                    reader.Read();
                    title = reader.Value;

                    reader.ReadToFollowing("ReleaseDate");
                    reader.Read();
                    releaseDate = reader.Value;

                    reader.ReadToFollowing("Platform");
                    reader.Read();
                    console = reader.Value;

                    App.ViewModel.SearchView.GamesList.Add(new GameData()
                    {
                        GameTitle       = title,
                        GameConsole     = console,
                        GameReleaseDate = releaseDate,
                        GameCover       = imageURL,
                        GameID          = gameID
                    });

                    title       = String.Empty;
                    gameID      = 0;
                    imageURL    = String.Empty;
                    releaseDate = String.Empty;
                    console     = String.Empty;
                }
            }
        }
示例#12
0
        private IEnumerable <DEMFileSource> GetSources(DEMDataSet dataSet, string vrtFileName)
        {
            Uri localVrtUri  = new Uri(Path.GetFullPath(vrtFileName), UriKind.Absolute);
            Uri remoteVrtUri = new Uri(dataSet.DataSource.IndexFilePath, UriKind.Absolute);

            double[] geoTransform;
            var      registration = dataSet.FileFormat.Registration;
            Dictionary <string, string> properties;

            // Create an XmlReader
            using (FileStream fileStream = new FileStream(vrtFileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
                using (XmlReader reader = XmlReader.Create(fileStream))
                {
                    if (reader.ReadToFollowing("GeoTransform"))
                    {
                        geoTransform = ParseGeoTransform(reader.ReadElementContentAsString());
                    }
                    else
                    {
                        throw new Exception("GeoTransform element not found!");
                    }

                    string sourceName = "";
                    if (reader.ReadToFollowing("VRTRasterBand"))
                    {
                        properties = new Dictionary <string, string>();
                        while (reader.Read())
                        {
                            if (reader.NodeType == XmlNodeType.Element)
                            {
                                if (reader.Name == "ComplexSource" || reader.Name == "SimpleSource")
                                {
                                    sourceName = reader.Name;
                                    break;
                                }
                                properties[reader.Name] = reader.ReadElementContentAsString();
                            }
                        }


                        bool isOnFirstSource = true;
                        while (isOnFirstSource || reader.ReadToFollowing(sourceName))
                        {
                            DEMFileSource source = ParseGDALSource(reader);

                            // SetLocalFileName
                            source.SourceFileNameAbsolute = new Uri(remoteVrtUri, source.SourceFileName).ToString();
                            source.LocalFileName          = new Uri(localVrtUri, source.SourceFileName).LocalPath;

                            // Transform origin
                            // Xp = padfTransform[0] + P * padfTransform[1] + L * padfTransform[2];
                            // Yp = padfTransform[3] + P * padfTransform[4] + L * padfTransform[5];
                            source.OriginLon = geoTransform[0] + source.DstxOff * geoTransform[1] + source.DstyOff * geoTransform[2];
                            source.OriginLat = geoTransform[3] + source.DstxOff * geoTransform[4] + source.DstyOff * geoTransform[5];
                            source.DestLon   = geoTransform[0] + (source.DstxOff + source.DstxSize) * geoTransform[1] + (source.DstyOff + source.DstySize) * geoTransform[2];
                            source.DestLat   = geoTransform[3] + (source.DstxOff + source.DstxSize) * geoTransform[4] + (source.DstyOff + source.DstySize) * geoTransform[5];

                            if (registration == DEMFileRegistrationMode.Grid)
                            {
                                source.BBox = new BoundingBox(Math.Round(source.OriginLon + geoTransform[1] / 2, 10),
                                                              Math.Round(source.DestLon - +geoTransform[1] / 2, 10),
                                                              Math.Round(source.DestLat - geoTransform[5] / 2, 10),
                                                              Math.Round(source.OriginLat + geoTransform[5] / 2, 10));
                            }
                            else
                            {
                                source.OriginLon = Math.Round(source.OriginLon, 10);
                                source.OriginLat = Math.Round(source.OriginLat, 10);
                                source.DestLon   = Math.Round(source.DestLon, 10);
                                source.DestLat   = Math.Round(source.DestLat, 10);
                                source.BBox      = new BoundingBox(source.OriginLon, source.DestLon, source.DestLat, source.OriginLat);
                            }


                            isOnFirstSource = false;

                            yield return(source);
                        }
                    }
                }
        }
示例#13
0
        private void ReadSheetGlobals(XlsxWorksheet sheet)
        {
            if (_xmlReader != null)
            {
                _xmlReader.Close();
            }
            if (_sheetStream != null)
            {
                _sheetStream.Close();
            }

            _sheetStream = _zipWorker.GetWorksheetStream(sheet.Path);

            if (null == _sheetStream)
            {
                return;
            }

            _xmlReader = XmlReader.Create(_sheetStream);

            //count rows and cols in case there is no dimension elements
            int rows = 0;
            int cols = 0;

            _namespaceUri = null;

            while (_xmlReader.Read())
            {
                if (_xmlReader.NodeType == XmlNodeType.Element && _xmlReader.LocalName == XlsxWorksheet.N_worksheet)
                {
                    //grab the namespaceuri from the worksheet element
                    _namespaceUri = _xmlReader.NamespaceURI;
                }

                if (_xmlReader.NodeType == XmlNodeType.Element && _xmlReader.LocalName == XlsxWorksheet.N_dimension)
                {
                    string dimValue = _xmlReader.GetAttribute(XlsxWorksheet.A_ref);

                    sheet.Dimension = new XlsxDimension(dimValue);
                    break;
                }

                if (_xmlReader.NodeType == XmlNodeType.Element && _xmlReader.LocalName == XlsxWorksheet.N_col)
                {
                    cols++;
                }

                if (_xmlReader.NodeType == XmlNodeType.Element && _xmlReader.LocalName == XlsxWorksheet.N_row)
                {
                    rows++;
                }
            }


            //if we didn't get a dimension element then use the calculated rows/cols to create it
            if (sheet.Dimension == null)
            {
                if (rows == 9 || cols == 0)
                {
                    sheet.IsEmpty = true;
                    return;
                }

                sheet.Dimension = new XlsxDimension(rows, cols);

                //we need to reset our position to sheet data
                _xmlReader.Close();
                _sheetStream.Close();
                _sheetStream = _zipWorker.GetWorksheetStream(sheet.Path);
                _xmlReader   = XmlReader.Create(_sheetStream);
            }

            //read up to the sheetData element. if this element is empty then there aren't any rows and we need to null out dimension

            _xmlReader.ReadToFollowing(XlsxWorksheet.N_sheetData, _namespaceUri);
            if (_xmlReader.IsEmptyElement)
            {
                sheet.IsEmpty = true;
            }
        }
	private void LoadEnemies(XmlReader reader) {
		reader.ReadStartElement("Enemies");

		GameObject enemy = null;
		bool enemyToParse = reader.ReadToFollowing ("Enemy");
		Debug.Log ("Started parsing enemies..." + enemyToParse);
		do {
			if(!enemyToParse)
				break;
			
			Debug.Log ("Found an enemy");
			switch (reader.GetAttribute ("Type")) {
			case "Bat":
				enemy = Instantiate (prefabDictionary ["Bat"]);
				break;
			case "Blob":
				enemy = Instantiate (prefabDictionary ["Blob"]);
				break;
			} 
			enemy.GetComponent<Enemy> ().Load (reader);
		} while(reader.ReadToNextSibling("Enemy"));

	}
示例#15
0
        public static List <XmlNodeItem> GetXMLNodesItems(XmlDocument xmlDoc, bool DisableProhibitDtd = false)
        {
            List <XmlNodeItem> returnDict = new List <XmlNodeItem>();
            XmlReader          rdr1       = XmlReader.Create(new System.IO.StringReader(xmlDoc.InnerXml));
            XmlReader          rdr        = null;

            if (DisableProhibitDtd)
            {
                XmlReaderSettings settings = new XmlReaderSettings();
                settings.DtdProcessing = DtdProcessing.Parse;

                rdr = XmlReader.Create(new System.IO.StringReader(xmlDoc.InnerXml), settings);
            }
            else
            {
                rdr = XmlReader.Create(new System.IO.StringReader(xmlDoc.InnerXml));
            }

            XmlReader subrdr = null;
            string    Elm    = "";

            ArrayList ls = new ArrayList();
            Dictionary <string, int> lspath   = new Dictionary <string, int>();
            List <string>            DeParams = new List <string>();

            while (rdr.Read())
            {
                if (rdr.NodeType == XmlNodeType.Element)
                {
                    Elm = rdr.Name;
                    if (ls.Count <= rdr.Depth)
                    {
                        ls.Add(Elm);
                    }
                    else
                    {
                        ls[rdr.Depth] = Elm;
                    }
                    foreach (var p in DeParams)
                    {
                        if (p == rdr.Name)
                        {
                            subrdr = rdr.ReadSubtree();
                            subrdr.ReadToFollowing(p);
                            returnDict.Add(new XmlNodeItem("AllDescOf" + p, subrdr.ReadInnerXml(), "/" + string.Join("/", ls.ToArray().Take(rdr.Depth))));
                            subrdr = null;
                        }
                    }
                }

                if (rdr.NodeType == XmlNodeType.Text)
                {
                    // soup req contains sub xml, so parse them
                    if (rdr.Value.StartsWith("<?xml"))
                    {
                        XmlDocument xmlnDoc = new XmlDocument();
                        xmlnDoc.LoadXml(rdr.Value);
                        GetXMLNodesItems(xmlnDoc);
                    }
                    else
                    {
                        if (!lspath.Keys.Contains("/" + string.Join("/", ls.ToArray().Take(rdr.Depth)) + "/" + Elm))
                        {
                            returnDict.Add(new XmlNodeItem(Elm, rdr.Value, "/" + string.Join("/", ls.ToArray().Take(rdr.Depth))));
                            lspath.Add("/" + string.Join("/", ls.ToArray().Take(rdr.Depth)) + "/" + Elm, 0);
                        }
                        else if (lspath.Keys.Contains("/" + string.Join("/", ls.ToArray().Take(rdr.Depth)) + "/" + Elm))
                        {
                            returnDict.Add(new XmlNodeItem(Elm + "_" + lspath["/" + string.Join("/", ls.ToArray().Take(rdr.Depth)) + "/" + Elm], rdr.Value, "/" + string.Join("/", ls.ToArray().Take(rdr.Depth))));
                            lspath["/" + string.Join("/", ls.ToArray().Take(rdr.Depth)) + "/" + Elm]++;
                        }
                    }
                }
            }
            return(returnDict);
        }
示例#16
0
        private void button2_Click(object sender, EventArgs e)
        {
            //SAVE FILE
            OpenFileDialog dialog = new OpenFileDialog();

            dialog.Filter = "*.xml|*.xml";

            //LOAD FILE
            if (dialog.ShowDialog() == DialogResult.OK)
            {
                using (FileStream fs = new FileStream(dialog.FileName, FileMode.Open, FileAccess.Read))
                    using (XmlTextReader reader = new XmlTextReader(fs))
                    {
                        reader.ReadStartElement();


                        uint   cexp     = 0;
                        uint   jexp     = 0;
                        uint   userid   = 0;
                        string charname = "";
                        byte   job      = 0;
                        byte   map      = 0;
                        byte[] buffer   = new byte[5];

                        charname = reader.ReadElementString();
                        if (reader.IsStartElement("CharFace"))
                        {
                            XmlReader innerreader = reader.ReadSubtree();
                            int       _pos        = 0;
                            while (innerreader.ReadToFollowing("details"))
                            {
                                byte.TryParse(innerreader.ReadElementString(), out buffer[_pos]);
                                _pos++;
                            }
                            reader.ReadEndElement();
                        }


                        uint.TryParse(reader.ReadElementString(), out userid);
                        uint.TryParse(reader.ReadElementString(), out cexp);
                        uint.TryParse(reader.ReadElementString(), out jexp);
                        byte.TryParse(reader.ReadElementString(), out job);
                        byte.TryParse(reader.ReadElementString(), out map);



                        reader.ReadEndElement();

                        MySqlCommand command = new MySqlCommand("INSERT INTO characters (`CharId`,`CharName`,`CharFace`,`UserId`,`Cexp`,`Jexp`,`Job`,`Map`) VALUES (?CharId, ?CharName, ?CharFace, ?UserId, ?Cexp, ?Jexp, ?Job, ?Map) ON duplicate KEY UPDATE `CharName`=?CharName,`CharFace`=?CharFace,`UserId`=?UserId,`Cexp`=?Cexp,`Jexp`=?Jexp,`Job`=?Job,`Map`=?Map", conn);
                        command.Parameters.AddWithValue("CharId", uint.Parse(textBox1.Text, NumberFormatInfo.InvariantInfo));
                        command.Parameters.AddWithValue("CharName", charname);
                        command.Parameters.AddWithValue("CharFace", buffer);
                        command.Parameters.AddWithValue("UserId", userid);
                        command.Parameters.AddWithValue("Cexp", cexp);
                        command.Parameters.AddWithValue("Jexp", jexp);
                        command.Parameters.AddWithValue("Job", job);
                        command.Parameters.AddWithValue("Map", map);
                        command.ExecuteNonQuery();
                    }
            }
        }
示例#17
0
        /// <summary>
        /// Get Remaining Activation Count for a MAK Product Key
        /// </summary>
        /// <param name="pid">Extended PID of the Key</param>
        /// <returns>Number of Activations and whether or not the Key is blocked from further Activation</returns>
        private static string GetRemainingActivations(string pid)
        {
            // Microsoft's PRIVATE KEY for HMAC-SHA256 encoding
            byte[] bPrivateKey = { 0xfe, 0x31, 0x98, 0x75, 0xfb, 0x48, 0x84, 0x86, 0x9c, 0xf3, 0xf1, 0xce, 0x99, 0xa8, 0x90, 0x64, 0xab, 0x57, 0x1f, 0xca, 0x47, 0x04, 0x50, 0x58, 0x30, 0x24, 0xe2, 0x14, 0x62, 0x87, 0x79, 0xa0 };

            // XML Namespace
            const string uri = "http://www.microsoft.com/DRM/SL/BatchActivationRequest/1.0";

            // Create new XML Document
            XmlDocument xmlDoc = new XmlDocument();

            // Create Root Element
            XmlElement rootElement = xmlDoc.CreateElement("ActivationRequest", uri);

            xmlDoc.AppendChild(rootElement);

            // Create VersionNumber Element
            XmlElement versionNumber = xmlDoc.CreateElement("VersionNumber", rootElement.NamespaceURI);

            versionNumber.InnerText = "2.0";
            rootElement.AppendChild(versionNumber);

            // Create RequestType Element
            XmlElement requestType = xmlDoc.CreateElement("RequestType", rootElement.NamespaceURI);

            requestType.InnerText = "2";
            rootElement.AppendChild(requestType);

            // Create Requests Group Element
            XmlElement requestsGroupElement = xmlDoc.CreateElement("Requests", rootElement.NamespaceURI);

            // Create Request Element
            XmlElement requestElement = xmlDoc.CreateElement("Request", requestsGroupElement.NamespaceURI);

            // Add PID as Request Element
            XmlElement pidEntry = xmlDoc.CreateElement("PID", requestElement.NamespaceURI);

            pidEntry.InnerText = pid.Replace("XXXXX", "55041");
            requestElement.AppendChild(pidEntry);

            // Add Request Element to Requests Group Element
            requestsGroupElement.AppendChild(requestElement);

            // Add Requests and Request to XML Document
            rootElement.AppendChild(requestsGroupElement);

            // Get Unicode Byte Array of XML Document
            byte[] byteXml = Encoding.Unicode.GetBytes(xmlDoc.InnerXml);

            // Convert Byte Array to Base64
            string base64Xml = Convert.ToBase64String(byteXml);

            // Compute Digest of the Base 64 XML Bytes
            // DO NOT Put into Using Block
            HMACSHA256 hmacsha256 = new HMACSHA256
            {
                Key = bPrivateKey
            };
            string digest = Convert.ToBase64String(hmacsha256.ComputeHash(byteXml));

            // Create SOAP Envelope for Web Request
            string form = "<?xml version=\"1.0\" encoding=\"utf-8\"?><soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"><soap:Body><BatchActivate xmlns=\"http://www.microsoft.com/BatchActivationService\"><request><Digest>REPLACEME1</Digest><RequestXml>REPLACEME2</RequestXml></request></BatchActivate></soap:Body></soap:Envelope>";

            form = form.Replace("REPLACEME1", digest);      // Put your Digest value (BASE64 encoded)
            form = form.Replace("REPLACEME2", base64Xml);   // Put your Base64 XML value (BASE64 encoded)
            XmlDocument soapEnvelopeXml = new XmlDocument();

            soapEnvelopeXml.LoadXml(form);

            // Create Web Request
            HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create("https://activation.sls.microsoft.com/BatchActivation/BatchActivation.asmx");

            webRequest.Method      = "POST";
            webRequest.ContentType = "text/xml; charset=\"utf-8\"";
            webRequest.Headers.Add("SOAPAction", "http://www.microsoft.com/BatchActivationService/BatchActivate");
            webRequest.Host = "activation.sls.microsoft.com";

            // Insert SOAP Envelope into Web Request
            using (Stream stream = webRequest.GetRequestStream())
            {
                soapEnvelopeXml.Save(stream);
            }

            // Begin Async call to Web Request
            IAsyncResult asyncResult = webRequest.BeginGetResponse(null, null);

            // Suspend Thread until call is complete
            asyncResult.AsyncWaitHandle.WaitOne();

            // Get the Response from the completed Web Request
            string soapResult;

            using (WebResponse webResponse = webRequest.EndGetResponse(asyncResult))
                // ReSharper disable AssignNullToNotNullAttribute
                using (StreamReader rd = new StreamReader(webResponse.GetResponseStream()))
                // ReSharper restore AssignNullToNotNullAttribute
                {
                    soapResult = rd.ReadToEnd();
                }

            // Parse the ResponseXML from the Response
            using (XmlReader soapReader = XmlReader.Create(new StringReader(soapResult)))
            {
                // Read ResponseXML Value
                soapReader.ReadToFollowing("ResponseXml");
                string responseXml = soapReader.ReadElementContentAsString();

                // Remove HTML Entities from ResponseXML
                responseXml = responseXml.Replace("&gt;", ">");
                responseXml = responseXml.Replace("&lt;", "<");

                // Change Encoding Value in ResponseXML
                responseXml = responseXml.Replace("utf-16", "utf-8");

                // Read Fixed ResponseXML Value as XML
                using (XmlReader reader = XmlReader.Create(new StringReader(responseXml)))
                {
                    reader.ReadToFollowing("ActivationRemaining");
                    string count = reader.ReadElementContentAsString();

                    if (Convert.ToInt32(count) < 0)
                    {
                        reader.ReadToFollowing("ErrorCode");
                        string error = reader.ReadElementContentAsString();

                        if (error == "0x67")
                        {
                            return("0 (Blocked)");
                        }
                    }
                    return(count);
                }
            }
        }
示例#18
0
	protected void LoadPosition(XmlReader reader) {
		reader.ReadToFollowing ("Position");
		reader.ReadToDescendant ("x");
		Vector3 loadedPosition = new Vector3 ();
		loadedPosition.x = reader.ReadElementContentAsFloat ();
		reader.ReadToNextSibling ("y");
		loadedPosition.y = reader.ReadElementContentAsFloat ();
		reader.ReadToNextSibling ("z");
		loadedPosition.z = reader.ReadElementContentAsFloat ();
		transform.position = loadedPosition;
		reader.ReadEndElement ();
	}
示例#19
0
        /// <summary>
        /// Creates an IFCFile object from an IFC XML file.
        /// </summary>
        /// <param name="path">The file path.</param>
        /// <param name="schemaVersion">The schema version.</param>
        /// <returns>The IFCFile.</returns>
        static IFCFile CreateIFCFileFromIFCXML(string path, out IFCSchemaVersion schemaVersion)
        {
            IFCFile file       = null;
            string  schemaName = null;

            schemaVersion = IFCSchemaVersion.IFC2x3;

            // This is an optional location to find the schema name - it may not be supplied.
            using (XmlReader reader = XmlReader.Create(new StreamReader(path)))
            {
                reader.ReadToFollowing("doc:express");
                reader.MoveToAttribute("schema_name");
                schemaName = reader.Value.Replace(" ", "").Replace("\t", "").Replace("\r", "").Replace("\n", "");
            }

            // This is an alternate location compatible with some MAP ifcXML files.
            if (string.IsNullOrEmpty(schemaName))
            {
                using (XmlReader reader = XmlReader.Create(new StreamReader(path)))
                {
                    reader.ReadToFollowing("doc:iso_10303_28");
                    reader.MoveToAttribute("xmlns:schemaLocation");
                    int ifcLoc = reader.Value.IndexOf("IFC");
                    if (ifcLoc >= 0)
                    {
                        string tmpName   = reader.Value.Substring(ifcLoc);
                        int    ifcEndLoc = tmpName.IndexOf('/');
                        if (ifcEndLoc > 0)
                        {
                            schemaName = tmpName.Substring(0, ifcEndLoc);
                        }
                    }
                }
            }

            // This checks to see if we have an unsupported IFC2X3_RC1 file.
            if (string.IsNullOrEmpty(schemaName))
            {
                using (XmlReader reader = XmlReader.Create(new StreamReader(path)))
                {
                    reader.ReadToFollowing("ex:iso_10303_28");
                    reader.MoveToAttribute("xmlns:ifc");
                    int ifcLoc = reader.Value.IndexOf("IFC");
                    if (ifcLoc >= 0)
                    {
                        schemaName = reader.Value.Substring(ifcLoc);
                    }
                }
            }

            if (!string.IsNullOrEmpty(schemaName))
            {
                IFCFileModelOptions modelOptions = GetIFCFileModelOptions(schemaName, out schemaVersion);
                file = IFCFile.Create(modelOptions);
            }

            if (file == null)
            {
                throw new InvalidOperationException("Can't determine XML file schema.");
            }

            return(file);
        }
示例#20
0
        public string DoExport(string blobUri, bool whatIf)
        {
            _log.Info("Starting SQL DAC Export Operation");
            string requestGuid      = null;
            bool   exportComplete   = false;
            string exportedBlobPath = null;

            //Setup Web Request for Export Operation
            WebRequest webRequest = WebRequest.Create(this.EndPointUri + @"/Export");

            webRequest.Method      = WebRequestMethods.Http.Post;
            webRequest.ContentType = @"application/xml";

            //Create Web Request Inputs - Blob Storage Credentials and Server Connection Info
            ExportInput exportInputs = new ExportInput
            {
                BlobCredentials = new BlobStorageAccessKeyCredentials
                {
                    StorageAccessKey = this.StorageKey,
                    Uri = String.Format(blobUri, this.DatabaseName, DateTime.UtcNow.Ticks.ToString())
                },
                ConnectionInfo = new ConnectionInfo
                {
                    ServerName   = this.ServerName,
                    DatabaseName = this.DatabaseName,
                    UserName     = this.UserName,
                    Password     = this.Password
                }
            };

            //Perform Web Request
            DataContractSerializer dataContractSerializer = new DataContractSerializer(exportInputs.GetType());

            _log.Info("http POST {0}", webRequest.RequestUri.AbsoluteUri);
            if (whatIf)
            {
                _log.Trace("Would have sent:");

                using (var strm = new MemoryStream())
                {
                    dataContractSerializer.WriteObject(strm, exportInputs);
                    strm.Flush();
                    strm.Seek(0, SeekOrigin.Begin);
                    using (var reader = new StreamReader(strm))
                    {
                        _log.Trace(reader.ReadToEnd());
                    }
                }
                return(null);
            }
            else
            {
                _log.Info("Making Web Request For Export Operation...");
                Stream webRequestStream = webRequest.GetRequestStream();
                dataContractSerializer.WriteObject(webRequestStream, exportInputs);
                webRequestStream.Close();

                //Get Response and Extract Request Identifier
                WebResponse webResponse     = null;
                XmlReader   xmlStreamReader = null;

                try
                {
                    //Initialize the WebResponse to the response from the WebRequest
                    webResponse = webRequest.GetResponse();

                    // See CA3053. Default XmlReaderSettings contains an insecure XmlResolver. Best to specify null.
                    XmlReaderSettings xmlSettings = new XmlReaderSettings();
                    xmlSettings.XmlResolver = null;
                    xmlStreamReader         = XmlReader.Create(webResponse.GetResponseStream(), xmlSettings);
                    xmlStreamReader.ReadToFollowing("guid");
                    requestGuid = xmlStreamReader.ReadElementContentAsString();
                    _log.Info($"Export Request '{requestGuid}' submitted");

                    //Get Export Operation Status
                    string last = null;
                    while (!exportComplete)
                    {
                        List <StatusInfo> statusInfoList = CheckRequestStatus(requestGuid);
                        var status = statusInfoList.FirstOrDefault().Status;
                        if (!String.Equals(last, status, StringComparison.OrdinalIgnoreCase))
                        {
                            _log.Info(status);
                        }
                        last = status;

                        if (statusInfoList.FirstOrDefault().Status == "Failed")
                        {
                            _log.Error("Database export failed: {0}", statusInfoList.FirstOrDefault().ErrorMessage);
                            exportComplete = true;
                        }

                        if (statusInfoList.FirstOrDefault().Status == "Completed")
                        {
                            exportedBlobPath = statusInfoList.FirstOrDefault().BlobUri;
                            _log.Info("Export Complete - Database exported to: {0}", exportedBlobPath);
                            exportComplete = true;
                        }
                        Thread.Sleep(5 * 1000);
                    }
                    return(exportedBlobPath);
                }
                catch (WebException responseException)
                {
                    _log.Error("Request Falied:{0}", responseException.Message);
                    if (responseException.Response != null)
                    {
                        _log.Error("Status Code: {0}", ((HttpWebResponse)responseException.Response).StatusCode);
                        _log.Error("Status Description: {0}", ((HttpWebResponse)responseException.Response).StatusDescription);
                    }
                    return(null);
                }
            }
        }
示例#21
0
        // searches the pages list for the proper page to add overlay to
        // creates an overlay for each orientation if there are more than one
        public Article parseOverlays(XmlReader reader, Article article)
        {
            while (reader.ReadToFollowing("overlay"))
            {
                double portraitX       = -1;
                double portraitY       = -1;
                double landscapeX      = -1;
                double landscapeY      = -1;
                double portraitWidth   = -1;
                double portraitHeight  = -1;
                double landscapeWidth  = -1;
                double landscapeHeight = -1;

                Tuple <int, double> portraitTuple  = new Tuple <int, double>(-1, -1);
                Tuple <int, double> landscapeTuple = new Tuple <int, double>(-1, -1);

                string type = reader.GetAttribute("type");
                string id   = reader.GetAttribute("id");

                while (reader.Read())
                {
                    // indicates the end of the overlay
                    if (reader.Name == "data")
                    {
                        break;
                    }
                    else if (reader.NodeType != XmlNodeType.EndElement)
                    {
                        //assigns the attributes for portrait orientation if it exists
                        if (reader.Name == "portraitBounds")
                        {
                            if (reader.ReadToFollowing("rectangle"))
                            {
                                portraitX      = Convert.ToDouble(reader.GetAttribute("x"));
                                portraitY      = Convert.ToDouble(reader.GetAttribute("y"));
                                portraitWidth  = Convert.ToDouble(reader.GetAttribute("width"));
                                portraitHeight = Convert.ToDouble(reader.GetAttribute("height"));
                                portraitTuple  = calculatePortraitPage(portraitY, article.Pages);
                            }
                        }
                        //assigns the attributes for landscape orientation if it exists
                        else if (reader.Name == "landscapeBounds")
                        {
                            if (reader.ReadToFollowing("rectangle"))
                            {
                                landscapeX      = Convert.ToDouble(reader.GetAttribute("x"));
                                landscapeY      = Convert.ToDouble(reader.GetAttribute("y"));
                                landscapeWidth  = Convert.ToDouble(reader.GetAttribute("width"));
                                landscapeHeight = Convert.ToDouble(reader.GetAttribute("height"));
                                landscapeTuple  = calculateLandscapePage(landscapeY, article.Pages);
                            }
                        }
                    }
                }

                switch (type)
                {
                case "audio":
                    AudioOverlay portraitAO  = new AudioOverlay();
                    AudioOverlay landscapeAO = new AudioOverlay();

                    // getting the overlay assets for each oreintation if there are any
                    do
                    {
                        if (reader.Name == "audioUrl")
                        {
                            break;
                        }
                        else if (reader.Name == "overlayAsset")
                        {
                            if (reader.GetAttribute("landscape") == "false")
                            {
                                portraitAO.OverlayAssets.Add(parseOverlayAsset(reader));
                            }
                            else if (reader.GetAttribute("landscape") == "true")
                            {
                                landscapeAO.OverlayAssets.Add(parseOverlayAsset(reader));
                            }
                        }
                    } while (reader.Read());

                    AudioOverlay ao = parseAudioOverlay(reader);

                    if (portraitTuple.Item1 != -1)      // there exists a portrait orientation for this overlay
                    {
                        portraitAO.Id             = id + "_P";
                        portraitAO.Orientation    = "portrait";
                        portraitAO.X              = portraitX;
                        portraitAO.Y              = portraitTuple.Item2;
                        portraitAO.Width          = portraitWidth;
                        portraitAO.Height         = portraitHeight;
                        portraitAO.AudioUrl       = ao.AudioUrl;
                        portraitAO.AutoStart      = ao.AutoStart;
                        portraitAO.AutoStartDelay = ao.AutoStartDelay;
                        article.Pages[portraitTuple.Item1].AudioOverlays.Add(portraitAO);
                    }
                    if (landscapeTuple.Item1 != -1)     // there exists a landscape orientation for this overlay
                    {
                        landscapeAO.Id             = id + "_L";
                        landscapeAO.Orientation    = "landscape";
                        landscapeAO.X              = landscapeX;
                        landscapeAO.Y              = landscapeTuple.Item2;
                        landscapeAO.Width          = landscapeWidth;
                        landscapeAO.Height         = landscapeHeight;
                        landscapeAO.AudioUrl       = ao.AudioUrl;
                        landscapeAO.AutoStart      = ao.AutoStart;
                        landscapeAO.AutoStartDelay = ao.AutoStartDelay;
                        article.Pages[landscapeTuple.Item1].AudioOverlays.Add(landscapeAO);
                    }
                    break;

                case "hyperlink":
                    HyperlinkOverlay ho          = parseHyperlinkOverlay(reader);
                    HyperlinkOverlay portraitHO  = new HyperlinkOverlay(ho);
                    HyperlinkOverlay landscapeHO = new HyperlinkOverlay(ho);

                    if (portraitTuple.Item1 != -1)     // there exists a portrait orientation for this overlay
                    {
                        portraitHO.Id          = id + "_P";
                        portraitHO.Orientation = "portrait";
                        portraitHO.X           = portraitX;
                        portraitHO.Y           = portraitTuple.Item2;
                        portraitHO.Width       = portraitWidth;
                        portraitHO.Height      = portraitHeight;
                        article.Pages[portraitTuple.Item1].HyperlinkOverlays.Add(portraitHO);
                    }
                    if (landscapeTuple.Item1 != -1)     // there exists a landscape orientation for this overlay
                    {
                        landscapeHO.Id          = id + "_L";
                        landscapeHO.Orientation = "landscape";
                        landscapeHO.X           = landscapeX;
                        landscapeHO.Y           = landscapeTuple.Item2;
                        landscapeHO.Width       = landscapeWidth;
                        landscapeHO.Height      = landscapeHeight;
                        article.Pages[landscapeTuple.Item1].HyperlinkOverlays.Add(landscapeHO);
                    }
                    break;

                case "imagepan":
                    ImagepanOverlay portraitIO  = new ImagepanOverlay();
                    ImagepanOverlay landscapeIO = new ImagepanOverlay();

                    // get overlay assets before we get the overlays attributes
                    while (reader.Read())
                    {
                        // indicates the end of the asstes
                        if (reader.Name == "anchorPoint")
                        {
                            break;
                        }
                        else if (reader.Name == "overlayAsset")
                        {
                            if (reader.GetAttribute("landscape") == "false")
                            {
                                portraitIO.OverlayAssets.Add(parseOverlayAsset(reader));
                            }
                            else if (reader.GetAttribute("landscape") == "true")
                            {
                                landscapeIO.OverlayAssets.Add(parseOverlayAsset(reader));
                            }
                        }
                    }

                    ImagepanOverlay io = parseImagepanOverlay(reader);

                    if (portraitTuple.Item1 != -1)      // there exists a portrait orientation for this overlay
                    {
                        portraitIO.Id          = id + "_P";
                        portraitIO.Orientation = "portrait";
                        portraitIO.X           = portraitX;
                        portraitIO.Y           = portraitTuple.Item2;
                        portraitIO.Width       = portraitWidth;
                        portraitIO.Height      = portraitHeight;
                        portraitIO.AnchorX     = io.AnchorX;
                        portraitIO.AnchorY     = io.AnchorY;
                        // getting the viewport bounds if they exist
                        while (reader.Read())
                        {
                            if ((reader.Name == "portraitBounds" && reader.NodeType == XmlNodeType.EndElement) || reader.Name == "landscapeBounds")
                            {
                                break;
                            }
                            else if (reader.Name == "portraitBounds")
                            {
                                portraitIO = parseImagepanOverlayViewportbounds(reader, portraitIO);
                            }
                        }

                        article.Pages[portraitTuple.Item1].ImagepanOverlays.Add(portraitIO);
                    }
                    if (landscapeTuple.Item1 != -1)      // there exists a landscape orientation for this overlay
                    {
                        landscapeIO.Id          = id + "_L";
                        landscapeIO.Orientation = "landscape";
                        landscapeIO.X           = landscapeX;
                        landscapeIO.Y           = landscapeTuple.Item2;
                        landscapeIO.Width       = landscapeWidth;
                        landscapeIO.Height      = landscapeHeight;
                        landscapeIO.AnchorX     = io.AnchorX;
                        landscapeIO.AnchorY     = io.AnchorY;
                        // getting the viewport bounds if they exist
                        do
                        {
                            if (reader.Name == "initialViewport" && reader.NodeType == XmlNodeType.EndElement)
                            {
                                break;
                            }
                            else if (reader.Name == "landscapeBounds")
                            {
                                landscapeIO = parseImagepanOverlayViewportbounds(reader, landscapeIO);
                            }
                        }while (reader.Read());

                        article.Pages[landscapeTuple.Item1].ImagepanOverlays.Add(landscapeIO);
                    }
                    break;

                case "slideshow":
                    // shared slideshow overlay attributes
                    SlideshowOverlay so = parseSlideShowOverlay(reader);

                    SlideshowOverlay portraitSO  = new SlideshowOverlay(so);
                    SlideshowOverlay landscapeSO = new SlideshowOverlay(so);

                    // getting the overlay assets for each oreintation if there are any
                    do
                    {
                        if (reader.Name == "portraitLayout" || reader.Name == "landscapeLayout")
                        {
                            break;
                        }
                        else if (reader.Name == "overlayAsset")
                        {
                            if (reader.GetAttribute("landscape") == "false")
                            {
                                portraitSO.OverlayAssets.Add(parseOverlayAsset(reader));
                            }
                            else if (reader.GetAttribute("landscape") == "true")
                            {
                                landscapeSO.OverlayAssets.Add(parseOverlayAsset(reader));
                            }
                        }
                    }while (reader.Read());

                    if (portraitTuple.Item1 != -1)      // there is a portrait layout for this overlay
                    {
                        portraitSO.Id          = id + "_P";
                        portraitSO.X           = portraitX;
                        portraitSO.Y           = portraitTuple.Item2;
                        portraitSO.Width       = portraitWidth;
                        portraitSO.Height      = portraitHeight;
                        portraitSO.Orientation = "portrait";

                        if (reader.Name == "portraitLayout")
                        {
                            portraitSO = parseSlideshowOverlayDisplaybounds(reader, portraitSO);
                            while (reader.Read())
                            {
                                if (reader.Name == "landscapeLayout" || (reader.Name == "data" && reader.NodeType == XmlNodeType.EndElement))
                                {
                                    break;
                                }
                                else if (reader.Name == "button")
                                {
                                    portraitSO.OverlayButtons.Add(parseOverlayButton(reader));
                                }
                            }
                        }
                        article.Pages[portraitTuple.Item1].SlideshowOverlays.Add(portraitSO);
                    }
                    if (landscapeTuple.Item1 != -1)      // there is a landscape layout for this overlay
                    {
                        landscapeSO.Id          = id + "_L";
                        landscapeSO.X           = landscapeX;
                        landscapeSO.Y           = landscapeTuple.Item2;
                        landscapeSO.Width       = landscapeWidth;
                        landscapeSO.Height      = landscapeHeight;
                        landscapeSO.Orientation = "landscape";

                        if (reader.Name == "landscapeLayout")
                        {
                            landscapeSO = parseSlideshowOverlayDisplaybounds(reader, landscapeSO);
                            while (reader.Read())
                            {
                                if (reader.Name == "data" && reader.NodeType == XmlNodeType.EndElement)
                                {
                                    break;
                                }
                                else if (reader.Name == "button")
                                {
                                    landscapeSO.OverlayButtons.Add(parseOverlayButton(reader));
                                }
                            }
                        }

                        article.Pages[landscapeTuple.Item1].SlideshowOverlays.Add(landscapeSO);
                    }
                    break;

                case "webview":
                    WebviewOverlay wo          = parseWebViewOverlay(reader);
                    WebviewOverlay portraitWO  = new WebviewOverlay(wo);
                    WebviewOverlay landscapeWO = new WebviewOverlay(wo);

                    if (portraitTuple.Item1 != -1)     // there is a portrait layout for this overlay
                    {
                        portraitWO.Id          = id + "_P";
                        portraitWO.Orientation = "portrait";
                        portraitWO.X           = portraitX;
                        portraitWO.Y           = portraitTuple.Item2;
                        portraitWO.Width       = portraitWidth;
                        portraitWO.Height      = portraitHeight;
                        article.Pages[portraitTuple.Item1].WebviewOverlay.Add(portraitWO);
                    }
                    if (landscapeTuple.Item1 != -1)     // there is a landscape layout for this overlay
                    {
                        landscapeWO.Id          = id + "_L";
                        landscapeWO.Orientation = "landscape";
                        landscapeWO.X           = landscapeX;
                        landscapeWO.Y           = landscapeTuple.Item2;
                        landscapeWO.Width       = landscapeWidth;
                        landscapeWO.Height      = landscapeHeight;
                        article.Pages[landscapeTuple.Item1].WebviewOverlay.Add(landscapeWO);
                    }
                    break;

                case "video":
                    VideoOverlay vo          = parseVideoOverlay(reader);
                    VideoOverlay portraitVO  = new VideoOverlay(vo);
                    VideoOverlay landscapeVO = new VideoOverlay(vo);

                    if (portraitTuple.Item1 != -1)      // there is a portrait layout for this overlay
                    {
                        portraitVO.Id          = id + "_P";
                        portraitVO.Orientation = "portrait";
                        portraitVO.X           = portraitX;
                        portraitVO.Y           = portraitTuple.Item2;
                        portraitVO.Width       = portraitWidth;
                        portraitVO.Height      = portraitHeight;
                        article.Pages[portraitTuple.Item1].VideoOverlays.Add(portraitVO);
                    }
                    if (landscapeTuple.Item1 != -1)      // there is a landscape layout for this overlay
                    {
                        landscapeVO.Id          = id + "_L";
                        landscapeVO.Orientation = "landscape";
                        landscapeVO.X           = landscapeX;
                        landscapeVO.Y           = landscapeTuple.Item2;
                        landscapeVO.Width       = landscapeWidth;
                        landscapeVO.Height      = landscapeHeight;
                        article.Pages[landscapeTuple.Item1].VideoOverlays.Add(landscapeVO);
                    }

                    break;

                default:
                    break;
                }
            }
            return(article);
        }
示例#22
0
        private async void pageRoot_Loaded_1(object sender, RoutedEventArgs e)
        {
            if (MediaControl.IsPlaying)
            {
                BG1.Begin();
            }

            if (Globalv.GlobalTopTracks.Count == 0)
            {
                progbar.Visibility = Visibility.Visible;
                bool success = false;
                try
                {
                    string resp = await Lastfm.chart_topTracks();

                    using (XmlReader rd = XmlReader.Create(new StringReader(resp)))
                    {
                        //for headliner
                        rd.ReadToFollowing("name");
                        GroupName = rd.ReadElementContentAsString();
                        rd.ReadToFollowing("playcount");
                        long pc = rd.ReadElementContentAsLong();
                        rd.ReadToFollowing("listeners");
                        long listeners = rd.ReadElementContentAsLong();
                        rd.ReadToFollowing("artist");
                        rd.ReadToDescendant("name");
                        string artist = rd.ReadElementContentAsString();
                        GroupDescription = "Artist: " + artist + "\nTrack heard over " + pc.ToString() + " times by " + listeners.ToString() + " listeners worldwide.";
                        Song s = new Song();
                        s.Artist = artist;
                        s.Title  = GroupName;
                        string resp2 = await Lastfm.track_getInfo(s);

                        using (XmlReader rd2 = XmlReader.Create(new StringReader(resp2)))
                        {
                            rd2.ReadToFollowing("album");
                            rd2.ReadToDescendant("image");
                            rd2.ReadToNextSibling("image");
                            rd2.ReadToNextSibling("image");

                            GroupImage = new BitmapImage(new Uri(rd2.ReadElementContentAsString(), UriKind.Absolute));
                        }
                        GNameTb.Text  = GroupName;
                        GImage.Source = GroupImage;
                        GDesc.Text    = GroupDescription;

                        //for other items
                        for (int i = 0; i < 19; i++)
                        {
                            //for headliner
                            Song s2 = new Song();
                            rd.ReadToFollowing("name");
                            s2.Title = rd.ReadElementContentAsString();
                            rd.ReadToFollowing("playcount");
                            long pclist = rd.ReadElementContentAsLong();
                            rd.ReadToFollowing("listeners");
                            long listenerslist = rd.ReadElementContentAsLong();
                            rd.ReadToFollowing("artist");
                            rd.ReadToDescendant("name");
                            s2.Artist  = rd.ReadElementContentAsString();
                            s2.content = "Artist: " + s2.Artist + "\nTrack heard over " + pclist.ToString() + " times by " + listenerslist.ToString() + " listeners worldwide.";
                            string resp22 = await Lastfm.track_getInfo(s2);

                            try
                            {
                                using (XmlReader rd2 = XmlReader.Create(new StringReader(resp22)))
                                {
                                    rd2.ReadToFollowing("album");
                                    rd2.ReadToFollowing("image");
                                    rd2.ReadToNextSibling("image");
                                    rd2.ReadToNextSibling("image");
                                    s2.image = new BitmapImage(new Uri(rd2.ReadElementContentAsString(), UriKind.Absolute));
                                }
                            }
                            catch (Exception) { }
                            TopTracks.Add(s2);
                        }
                        itemsGridView.ItemsSource = TopTracks;
                        Globalv.GlobalTopTracks   = TopTracks;
                    }
                    success = true;
                }
                catch (Exception)
                { success = false; }

                if (!success)
                {
                    MessageDialog m = new MessageDialog("This feature requires you to be connected to the internet. Connect to the internet and try again", "You're offline");
                    await m.ShowAsync();
                }
                progbar.Visibility = Visibility.Collapsed;
            }
            else
            {
                itemsGridView.ItemsSource = TopTracks;
            }
        }
示例#23
0
        public void Convert(TaskProgress progress)
        {
            MassSpectrum spec              = null;
            bool         isFirstScan       = true;
            int          currentMs1ScanNum = 0;
            bool         isScanMS2         = false;

            List <MassSpectrum> tmpMS1           = new List <MassSpectrum>();
            List <MassSpectrum> NeedToCorrectMS2 = new List <MassSpectrum>();

            using (XmlReader reader = XmlReader.Create(_mzmlFile))
            {
                reader.ReadToFollowing("mzML");
                XmlSerializer serializer = new XmlSerializer(typeof(mzMLType));

                //Reading mzML file to mzMLType class
                mzML = (mzMLType)serializer.Deserialize(reader);

                _scanCount = mzML.run.spectrumList.spectrum.Count();

                for (int i = 0; i < _scanCount; i++)
                {
                    int            scanNum               = System.Convert.ToInt32(mzML.run.spectrumList.spectrum[i].index.Replace("\"", ""));
                    InstrumentType instType              = InstrumentType.ELSE;
                    string         filter                = "";
                    string         refParGup             = "";
                    double         retentionTime         = 0;
                    int            msLevel               = 0;
                    double         lowMz                 = 0;
                    double         highMz                = 0;
                    double         basePeakMz            = 0;
                    double         basePeakIntensity     = 0;
                    double         totIonCurrent         = 0;
                    double         precursorMz           = 0;
                    int            precursorCharge       = 0;
                    byte[]         uncompressedMz        = null;
                    byte[]         uncompressedIntensity = null;
                    int            shiftByte             = 8;

                    if (mzML.run.spectrumList.spectrum[i].referenceableParamGroupRef != null)
                    {
                        // get referenceableParamGroup
                        refParGup = mzML.run.spectrumList.spectrum[i].referenceableParamGroupRef[0].@ref;
                        // reference to referenceableParamGroup includes ms level, low MZ, High MZ, basePeak MZ and basePeak Intensity
                        foreach (var refPargup in mzML.referenceableParamGroupList.referenceableParamGroup)
                        {
                            if (refPargup.id == refParGup)
                            {
                                foreach (var cvParm in refPargup.cvParam)
                                {
                                    switch (cvParm.name)
                                    {
                                    case "ms level":
                                        msLevel = System.Convert.ToInt32(cvParm.value.Replace("\"", ""));
                                        break;

                                    case "lowest observed m/z":
                                        lowMz = System.Convert.ToDouble(cvParm.value.Replace("\"", ""));
                                        break;

                                    case "highest observed m/z":
                                        highMz = System.Convert.ToDouble(cvParm.value.Replace("\"", ""));
                                        break;

                                    case "base peak m/z":
                                        basePeakMz = System.Convert.ToDouble(cvParm.value.Replace("\"", ""));
                                        break;

                                    case "base peak intensity":
                                        basePeakIntensity = System.Convert.ToDouble(cvParm.value.Replace("\"", ""));
                                        break;

                                    case "total ion current":
                                        totIonCurrent = System.Convert.ToDouble(cvParm.value.Replace("\"", ""));
                                        break;
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        // if there is no referenceableParamGroupRef get parameters from spectrum's cvParam
                        foreach (var cvParm in mzML.run.spectrumList.spectrum[i].cvParam)
                        {
                            switch (cvParm.name)
                            {
                            case "ms level":
                                msLevel = System.Convert.ToInt32(cvParm.value.Replace("\"", ""));
                                break;

                            case "lowest observed m/z":
                                lowMz = System.Convert.ToDouble(cvParm.value.Replace("\"", ""));
                                break;

                            case "highest observed m/z":
                                highMz = System.Convert.ToDouble(cvParm.value.Replace("\"", ""));
                                break;

                            case "base peak m/z":
                                basePeakMz = System.Convert.ToDouble(cvParm.value.Replace("\"", ""));
                                break;

                            case "base peak intensity":
                                basePeakIntensity = System.Convert.ToDouble(cvParm.value.Replace("\"", ""));
                                break;

                            case "total ion current":
                                totIonCurrent = System.Convert.ToDouble(cvParm.value.Replace("\"", ""));
                                break;
                            }
                        }
                    }


                    foreach (var cvParm in mzML.run.spectrumList.spectrum[i].scanList.scan[0].cvParam)
                    {
                        switch (cvParm.name)
                        {
                        case "scan start time":
                            //get retention Time
                            retentionTime = System.Convert.ToDouble(cvParm.value.Replace("\"", ""));
                            break;

                        case "filter string":
                            //get filter
                            filter = cvParm.value.Replace("\"", "");
                            break;
                        }
                    }

                    //set current MS1
                    if (msLevel == 1)
                    {
                        currentMs1ScanNum = scanNum;
                    }

                    //create a spectrum;
                    spec                     = new MassSpectrum(scanNum, mzML.run.spectrumList.spectrum[i].index.Replace("\"", ""), retentionTime, new List <Ion>(), 0, instType, filter, 0, false);
                    spec.MsLevel             = msLevel;
                    spec.LowMz               = lowMz;
                    spec.HighMz              = highMz;
                    spec.BasePeakMz          = basePeakMz;
                    spec.BasePeakIntensity   = basePeakIntensity;
                    spec.TotIonCurrent       = totIonCurrent;
                    spec.PrecursorScanNumber = currentMs1ScanNum;
                    spec.Precursors          = new List <Tuple <double, int> >();

                    //set MS2's precursor
                    if (msLevel == 2)
                    {
                        spec.PrecursorScanNumber = currentMs1ScanNum;
                        //get precursor
                        foreach (var precursorData in mzML.run.spectrumList.spectrum[i].precursorList.precursor[0].selectedIonList.selectedIon[0].cvParam)
                        {
                            if (precursorData.name == "selected ion m/z")
                            {
                                precursorMz = System.Convert.ToDouble(precursorData.value.Replace("\"", ""));
                            }
                            if (precursorData.name == "charge state")
                            {
                                precursorCharge = System.Convert.ToInt32(precursorData.value.Replace("\"", ""));
                            }
                        }
                        spec.Precursors.Add(new Tuple <double, int>(precursorMz, precursorCharge));
                    }


                    // get peaks
                    foreach (var data in mzML.run.spectrumList.spectrum[i].binaryDataArrayList.binaryDataArray)
                    {
                        bool mzArray         = false;
                        bool intensityArray  = false;
                        bool zlibCompression = false;

                        foreach (var cvParm in data.cvParam)
                        {
                            switch (cvParm.name)
                            {
                            case "m/z array":
                                mzArray = true;
                                break;

                            case "intensity array":
                                intensityArray = true;
                                break;

                            case "zlib compression":
                                zlibCompression = true;
                                break;

                            case "32-bit float":
                                shiftByte = 4;
                                break;
                            }
                        }

                        if (mzArray)
                        {
                            if (zlibCompression)
                            {
                                //uncompression m/z
                                uncompressedMz = Ionic.Zlib.ZlibStream.UncompressBuffer(data.binary);
                            }
                            else
                            {
                                uncompressedMz = data.binary;
                            }
                        }
                        else if (intensityArray)
                        {
                            if (zlibCompression)
                            {
                                //uncompression intensity
                                uncompressedIntensity = Ionic.Zlib.ZlibStream.UncompressBuffer(data.binary);
                            }
                            else
                            {
                                uncompressedIntensity = data.binary;
                            }
                        }
                    }

                    for (int byteIdx = 0; byteIdx < uncompressedMz.Length; byteIdx += shiftByte)
                    {
                        byte[] mzBytes = new byte[8];
                        Buffer.BlockCopy(uncompressedMz, byteIdx, mzBytes, 0, shiftByte);

                        // retrieve the mz and intensity;
                        double mz = BitConverter.ToDouble(mzBytes, 0);

                        byte[] intBytes = new byte[8];
                        Buffer.BlockCopy(uncompressedIntensity, byteIdx, intBytes, 0, shiftByte);
                        double intensity = BitConverter.ToDouble(intBytes, 0);

                        spec.Peaks.Add(new Ion(mz, intensity));
                    }


                    // Precursor Correct
                    if (_correctPrecMz)
                    {
                        if (spec.MsLevel == 1)
                        {
                            if (isScanMS2)
                            {
                                List <MassSpectrum> currentMS1 = new List <MassSpectrum>();
                                currentMS1.AddRange(tmpMS1);
                                currentMS1.Add(spec);

                                for (int j = 0; j < NeedToCorrectMS2.Count; j++)
                                {
                                    PrecursorCorrector pc = new PrecursorCorrector();

                                    // get the precursor m/z from the scan filter;
                                    double precMz = NeedToCorrectMS2[j].Precursors.Count == 0 ? 0 : NeedToCorrectMS2[j].Precursors[0].Item1;
                                    int    precZ  = NeedToCorrectMS2[j].Precursors.Count == 0 ? 0 : NeedToCorrectMS2[j].Precursors[0].Item2;

                                    MassSpectrum currentMS2 = NeedToCorrectMS2[j];

                                    pc.CorrectPrecursor(ref currentMS2, precMz, precZ, currentMS2.PrecursorScanNumber, currentMS1);

                                    WriteToOutFiles(currentMS2, isFirstScan);

                                    //clear variable in program
                                    if (j == (NeedToCorrectMS2.Count - 1))
                                    {
                                        WriteToOutFiles(spec, isFirstScan);
                                        isScanMS2 = false;
                                        currentMS1.Clear();
                                        NeedToCorrectMS2.Clear();
                                        if (tmpMS1.Count() >= 2)
                                        {
                                            tmpMS1.RemoveAt(1);
                                        }
                                        tmpMS1.Insert(0, spec);
                                    }
                                }
                            }
                            else
                            {
                                if (tmpMS1.Count() >= 2)
                                {
                                    tmpMS1.RemoveAt(1);
                                }
                                tmpMS1.Insert(0, spec);
                            }
                        }
                        else if (spec.MsLevel == 2)
                        {
                            NeedToCorrectMS2.Add(spec);
                            isScanMS2 = true;
                        }
                    }
                    else
                    {
                        WriteToOutFiles(spec, isFirstScan);
                    }

                    isFirstScan = false;
                    _spectrumProcessed++;

                    if (progress.Aborted)
                    {
                        break;
                    }

                    progress.CurrentProgress = (int)((double)_spectrumProcessed / _scanCount * 100);
                    //Console.WriteLine(_spectrumProcessed + "\t" + progress.CurrentProgress);
                    if (progress.CurrentProgress > _lastProgress)
                    {
                        _lastProgress = progress.CurrentProgress;
                        int currentLineCursor = Console.CursorTop;
                        Console.SetCursorPosition(0, Console.CursorTop);
                        Console.Write(" Reading mzML File: " + _lastProgress + "%");
                        Console.SetCursorPosition(0, currentLineCursor);
                    }
                }
            }
        }
示例#24
0
        /// <summary>
        /// Loads this BgfFile instance from XML/BMP
        /// </summary>
        /// <param name="Filename"></param>
        public void LoadXml(string Filename)
        {
            string path = Path.GetDirectoryName(Filename);

            // init XML reader
            XmlReader reader = XmlReader.Create(Filename);

            // rootnode
            reader.ReadToFollowing("bgf");
            uint version = Convert.ToUInt32(reader["version"]);

            if (version >= BgfFile.VERSION9)
            {
                ShrinkFactor = Convert.ToUInt32(reader["shrink"]);

                // skip maxindices, we use dynamic getter
                // MaxIndices = Convert.ToUInt32(reader["maxindices"]);

                // frames
                reader.ReadToFollowing("frames");
                int FrameCount = Convert.ToInt32(reader["count"]);
                Frames.Capacity = FrameCount;
                for (int i = 0; i < FrameCount; i++)
                {
                    reader.ReadToFollowing("frame");
                    uint   width   = Convert.ToUInt32(reader["width"]);
                    uint   height  = Convert.ToUInt32(reader["height"]);
                    int    xoffset = Convert.ToInt32(reader["xoffset"]);
                    int    yoffset = Convert.ToInt32(reader["yoffset"]);
                    string file    = reader["file"];

                    // hotspots
                    reader.ReadToFollowing("hotspots");
                    byte hotspotcount = Convert.ToByte(reader["count"]);
                    List <BgfBitmapHotspot> hotspots = new List <BgfBitmapHotspot>(hotspotcount);
                    for (int j = 0; j < hotspotcount; j++)
                    {
                        reader.ReadToFollowing("hotspot");
                        sbyte index = Convert.ToSByte(reader["index"]);
                        int   x     = Convert.ToInt32(reader["x"]);
                        int   y     = Convert.ToInt32(reader["y"]);

                        BgfBitmapHotspot hotspot = new BgfBitmapHotspot(index, x, y);
                        hotspots.Add(hotspot);
                    }

                    // load bitmap from file
                    Bitmap bmp = (Bitmap)Image.FromFile(path + "/" + file);

                    byte[]    pixelData = BgfBitmap.BitmapToPixelData(bmp);
                    BgfBitmap bgfBitmap = new BgfBitmap(
                        (uint)i + 1,
                        version,
                        width,
                        height,
                        xoffset,
                        yoffset,
                        hotspots,
                        false,
                        0,
                        pixelData);

                    // cleanp temporary bitmap
                    bmp.Dispose();

                    Frames.Add(bgfBitmap);
                }

                // framesets
                reader.ReadToFollowing("framesets");
                int FrameSetCount = Convert.ToInt32(reader["count"]);
                FrameSets.Capacity = FrameSetCount;
                for (int i = 0; i < FrameSetCount; i++)
                {
                    reader.ReadToFollowing("frameset");
                    string[]   indices    = reader["indices"].Split(' ');
                    List <int> intIndices = new List <int>();
                    foreach (string index in indices)
                    {
                        intIndices.Add(Convert.ToInt32(index));
                    }

                    BgfFrameSet bgfFrameSet = new BgfFrameSet((uint)i + 1, intIndices);

                    FrameSets.Add(bgfFrameSet);
                }
            }
            else
            {
                throw new Exception("Wrong format version: " + version + " (expected " + BgfFile.VERSION9 + ").");
            }
        }
示例#25
0
	/// <summary>
	/// Load an instance using the specified reader.
	/// </summary>
	/// <param name="reader">Reader.</param>
	public override void Load (XmlReader reader)
	{
		reader.ReadToFollowing ("Wizard");
		base.Load (reader);
		reader.ReadEndElement ();
	}
        public IEnumerator <float> CheckSteam(string userid)
        {
            PlayerData data = null;

            if (SanyaPlugin.Instance.Config.DataEnabled && SanyaPlugin.Instance.PlayerDataManager.PlayerDataDict.TryGetValue(userid, out data) &&
                (!SanyaPlugin.Instance.Config.KickSteamLimited || !data.steamlimited) &&
                (!SanyaPlugin.Instance.Config.KickSteamVacBanned || !data.steamvacbanned))
            {
                Log.Debug($"[SteamCheck] Already Checked:{userid}", SanyaPlugin.Instance.Config.IsDebugged);
                yield break;
            }

            string xmlurl = string.Concat(
                "https://steamcommunity.com/profiles/",
                userid.Replace("@steam", string.Empty),
                "?xml=1"
                );

            using (UnityWebRequest unityWebRequest = UnityWebRequest.Get(xmlurl))
            {
                yield return(Timing.WaitUntilDone(unityWebRequest.SendWebRequest()));

                if (!unityWebRequest.isNetworkError)
                {
                    XmlReaderSettings xmlReaderSettings = new XmlReaderSettings()
                    {
                        IgnoreComments = true, IgnoreWhitespace = true
                    };
                    XmlReader xmlReader   = XmlReader.Create(new MemoryStream(unityWebRequest.downloadHandler.data), xmlReaderSettings);
                    bool      ReadSuccess = false;
                    while (xmlReader.Read())
                    {
                        if (xmlReader.ReadToFollowing("vacBanned") && SanyaPlugin.Instance.Config.KickSteamVacBanned)
                        {
                            ReadSuccess = true;
                            string isVacBanned = xmlReader.ReadElementContentAsString();
                            if (isVacBanned == "0")
                            {
                                Log.Info($"[SteamCheck:VacBanned] OK:{userid}");
                                if (data != null)
                                {
                                    data.steamvacbanned = false;
                                    SanyaPlugin.Instance.PlayerDataManager.SavePlayerData(data);
                                }
                            }
                            else
                            {
                                Log.Warn($"[SteamCheck:VacBanned] NG:{userid}");
                                var player = Player.Get(userid);
                                if (player != null)
                                {
                                    ServerConsole.Disconnect(player.Connection, SanyaPlugin.Instance.Translation.VacBannedKickMessage);
                                }

                                if (!EventHandlers.kickedbyChecker.ContainsKey(userid))
                                {
                                    EventHandlers.kickedbyChecker.Add(userid, "steam_vac");
                                }
                            }
                        }

                        if (xmlReader.ReadToFollowing("isLimitedAccount") && SanyaPlugin.Instance.Config.KickSteamLimited)
                        {
                            ReadSuccess = true;
                            string isLimited = xmlReader.ReadElementContentAsString();
                            if (isLimited == "0")
                            {
                                Log.Info($"[SteamCheck:Limited] OK:{userid}");
                                if (data != null)
                                {
                                    data.steamlimited = false;
                                    SanyaPlugin.Instance.PlayerDataManager.SavePlayerData(data);
                                }
                            }
                            else
                            {
                                Log.Warn($"[SteamCheck:Limited] NG:{userid}");
                                var player = Player.Get(userid);
                                if (player != null)
                                {
                                    ServerConsole.Disconnect(player.Connection, SanyaPlugin.Instance.Translation.LimitedKickMessage);
                                }

                                if (!EventHandlers.kickedbyChecker.ContainsKey(userid))
                                {
                                    EventHandlers.kickedbyChecker.Add(userid, "steam_limited");
                                }
                            }
                        }


                        if (!ReadSuccess)
                        {
                            Log.Warn($"[SteamCheck] Falied(NoProfile or Error):{userid}");
                            var player = Player.Get(userid);
                            if (player != null)
                            {
                                ServerConsole.Disconnect(player.Connection, SanyaPlugin.Instance.Translation.NoProfileKickMessage);
                            }
                            if (!EventHandlers.kickedbyChecker.ContainsKey(userid))
                            {
                                EventHandlers.kickedbyChecker.Add(userid, "steam_noprofile");
                            }
                        }

                        yield break;
                    }
                }
                else
                {
                    Log.Error($"[SteamCheck] Failed(NetworkError):{userid}:{unityWebRequest.error}");
                    yield break;
                }
            }
            yield break;
        }
示例#27
0
        public string DoExport(string blobUri)
        {
            Console.Write(String.Format("Starting Export Operation - {0}\n\r", DateTime.Now));
            string requestGuid      = null;
            bool   exportComplete   = false;
            string exportedBlobPath = null;

            //Setup Web Request for Export Operation
            WebRequest webRequest = WebRequest.Create(this.EndPointUri + @"/Export");

            webRequest.Method      = WebRequestMethods.Http.Post;
            webRequest.ContentType = @"application/xml";

            //Create Web Request Inputs - Blob Storage Credentials and Server Connection Info
            ExportInput exportInputs = new ExportInput
            {
                BlobCredentials = new BlobStorageAccessKeyCredentials
                {
                    StorageAccessKey = this.StorageKey,
                    Uri = String.Format(blobUri, this.DatabaseName, DateTime.UtcNow.Ticks.ToString())
                },
                ConnectionInfo = new ConnectionInfo
                {
                    ServerName   = this.DatabaseServerName,
                    DatabaseName = this.DatabaseName,
                    UserName     = this.DatabaseServerUserName,
                    Password     = this.DatabaseServerPassword
                }
            };

            //Perform Web Request
            Console.WriteLine("Making Web Request For Export Operation...");
            Stream webRequestStream = webRequest.GetRequestStream();
            DataContractSerializer dataContractSerializer = new DataContractSerializer(exportInputs.GetType());

            dataContractSerializer.WriteObject(webRequestStream, exportInputs);
            webRequestStream.Close();

            //Get Response and Extract Request Identifier
            Console.WriteLine("Reading Response and extracting Export Request Identifier...");
            WebResponse webResponse     = null;
            XmlReader   xmlStreamReader = null;

            try
            {
                //Initialize the WebResponse to the response from the WebRequest
                webResponse = webRequest.GetResponse();

                xmlStreamReader = XmlReader.Create(webResponse.GetResponseStream());
                xmlStreamReader.ReadToFollowing("guid");
                requestGuid = xmlStreamReader.ReadElementContentAsString();
                Console.WriteLine(String.Format("Your Export Request Guid is: {0}", requestGuid));

                //Get Export Operation Status
                while (!exportComplete)
                {
                    Console.WriteLine("Checking export status...");
                    List <StatusInfo> statusInfoList = CheckRequestStatus(requestGuid);
                    Console.WriteLine(statusInfoList.FirstOrDefault().Status);

                    if (statusInfoList.FirstOrDefault().Status == "Failed")
                    {
                        Console.WriteLine(String.Format("Database export failed: {0}", statusInfoList.FirstOrDefault().ErrorMessage));
                        exportComplete = true;
                    }

                    if (statusInfoList.FirstOrDefault().Status == "Completed")
                    {
                        exportedBlobPath = statusInfoList.FirstOrDefault().BlobUri;
                        Console.WriteLine(String.Format("Export Complete - Database exported to: {0}\n\r", exportedBlobPath));
                        exportComplete = true;
                    }
                }
                return(exportedBlobPath);
            }
            catch (WebException responseException)
            {
                Console.WriteLine("Request Falied:{0}", responseException.Message);
                if (responseException.Response != null)
                {
                    Console.WriteLine("Status Code: {0}", ((HttpWebResponse)responseException.Response).StatusCode);
                    Console.WriteLine("Status Description: {0}\n\r", ((HttpWebResponse)responseException.Response).StatusDescription);
                }
                return(null);
            }
        }
示例#28
0
 /// <summary>
 ///   移动读取器到一个位置
 /// </summary>
 /// <param name="xr"> 读取器 </param>
 /// <param name="parfriend"> </param>
 /// <param name="path"> 路径 </param>
 /// <returns> 成功或失败 </returns>
 public static bool MoveXmlTo(XmlReader xr, string parfriend, string[] path)
 {
     return(xr.ReadToFollowing(parfriend) && MoveXmlTo(xr, path));
 }
示例#29
0
        public void ReadXml(XmlReader reader)
        {
            // Root element NOT handled automatically.
            reader.MoveToContent();
            var empty = reader.IsEmptyElement;

            //reader.ReadStartElement(); // Read root element.
            if (!empty)
            {
                // Application parameters.
                reader.ReadToFollowing("ApplicationParameters");
                using (var subtree = reader.ReadSubtree())
                {
                    subtree.MoveToContent();
                    while (subtree.Read())
                    {
                        if (subtree.IsStartElement())
                        {
                            typeof(LuiConfig).GetProperty(subtree.Name)
                            .SetValue(this, subtree.ReadElementContentAsString());
                        }
                    }
                }

                // LuiObjectParamters lists.
                var settings = new DataContractSerializerSettings
                {
                    PreserveObjectReferences = true,
                    KnownTypes = typeof(LuiObjectParameters).GetSubclasses(true)
                };
                var serializer = new DataContractSerializer(typeof(LuiObjectParameters), settings);

                reader.ReadToFollowing("LuiObjectParametersList");
                using (var subtree = reader.ReadSubtree())
                {
                    subtree.MoveToContent();
                    while (subtree.Read())
                    {
                        subtree.MoveToContent();
                        if (!subtree.Name.EndsWith("List") && subtree.IsStartElement())
                        {
                            var p = (LuiObjectParameters)serializer.ReadObject(subtree.ReadSubtree());
                            AddParameters(p);
                        }
                    }
                }

                // Tab settings.

                reader.ReadToFollowing("TabSettings");
                using (var subtree = reader.ReadSubtree())
                {
                    subtree.MoveToContent();
                    ISet <string> TabNames = new HashSet <string>(typeof(LuiTab).GetSubclasses(true).Select(x => x.Name));
                    string        Tab      = null;
                    while (subtree.Read())
                    {
                        subtree.MoveToContent();
                        if (subtree.IsStartElement())
                        {
                            if (TabNames.Contains(subtree.Name))
                            {
                                Tab = subtree.Name;
                            }
                            else
                            {
                                var Name = subtree.Name;
                                subtree.Read();
                                TabSettings[Tab].Add(Name, subtree.Value);
                            }
                        }
                    }
                }

                //reader.ReadEndElement(); // End root.
            }

            Saved = true;
        }
示例#30
0
文件: mavgraph.cs 项目: 894880010/MP
        public static void readmavgraphsxml()
        {
            if (readmavgraphsxml_runonce)
            {
                return;
            }

            readmavgraphsxml_runonce = true;

            List <graphitem> items = new List <graphitem>();

            log.Info("readmavgraphsxml from " + Settings.GetRunningDirectory() + Path.DirectorySeparatorChar +
                     "graphs");
            var files = Directory.GetFiles(Settings.GetRunningDirectory() + Path.DirectorySeparatorChar + "graphs",
                                           "*.xml");

            foreach (var file in files)
            {
                try
                {
                    log.Info("readmavgraphsxml file " + file);
                    using (
                        XmlReader reader =
                            XmlReader.Create(file))
                    {
                        while (reader.Read())
                        {
                            if (reader.ReadToFollowing("graph"))
                            {
                                graphitem newGraphitem = new graphitem();

                                for (int a = 0; a < reader.AttributeCount; a++)
                                {
                                    reader.MoveToAttribute(a);
                                    if (reader.Name.ToLower() == "name")
                                    {
                                        newGraphitem.name =
                                            reader.Value + " " + Path.GetFileNameWithoutExtension(file);
                                    }
                                }

                                reader.MoveToElement();

                                XmlReader inner = reader.ReadSubtree();

                                while (inner.Read())
                                {
                                    if (inner.IsStartElement())
                                    {
                                        if (inner.Name.ToLower() == "expression")
                                        {
                                            newGraphitem.expressions.Add(inner.ReadString().Trim());
                                        }
                                        else if (inner.Name.ToLower() == "description")
                                        {
                                            newGraphitem.description = inner.ReadString().Trim();
                                        }
                                    }
                                }

                                processGraphItem(newGraphitem);

                                items.Add(newGraphitem);
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    log.Error(ex);
                }
            }
        }
示例#31
0
        public List <string[]> LoadFromFile(int filterIndex, string path)
        {
            List <string[]> points = new List <string[]>();

            switch (filterIndex)
            {
            case 1:
                StreamReader stReader = new StreamReader(path);
                while (!stReader.EndOfStream)
                {
                    string[] line = stReader.ReadLine().Split(':');
                    points.Add(new string[] { line[0], line[1] });
                }
                stReader.Close();
                break;

            case 2:
                Stream stream;
                try
                {
                    stream = new FileStream(path, FileMode.Open);
                }
                catch (IOException e)
                {
                    //ImaginaryMessage im = new ImaginaryMessage();
                    //im.ShowMessage(e.Message);
                    throw e;
                }
                using (ExcelPackage excel = new ExcelPackage(stream))
                {
                    var worksheet = excel.Workbook.Worksheets.First();
                    for (int i = 0; true; i++)
                    {
                        string xInput = worksheet.Cells["A" + (i + 1)].Text;
                        string yInput = worksheet.Cells["B" + (i + 1)].Text;
                        if (xInput == "" && yInput == "")
                        {
                            break;
                        }
                        else
                        {
                            points.Add(new string[] { xInput, yInput });
                        }
                    }
                }
                stream.Close();
                break;

            case 3:
                using (XmlReader xmlReader = XmlReader.Create(path))
                {
                    string lat, lon = "";
                    while (xmlReader.Read())
                    {
                        xmlReader.ReadToFollowing("wpt");
                        if (xmlReader.IsStartElement())
                        {
                            lat = xmlReader.GetAttribute("lat");
                            lon = xmlReader.GetAttribute("lon");
                            points.Add(new string[] { lat, lon });
                        }
                    }
                }
                break;

            default:
                break;
            }
            return(points);
        }
示例#32
0
        /// <summary>
        /// Parses a saved configuration file and returns a UscSettings object.
        /// </summary>
        /// <param name="warnings">A list of warnings.  Whenever something goes
        /// wrong with the file loading, a warning will be added to this list.
        /// The warnings are not fatal; if the function returns it will return
        /// a valid UscSettings object.
        /// </param>
        /// <param name="sr">The file to read from.</param>
        /// <remarks>This function is messy.  Maybe I should have tried the XPath
        /// library.</remarks>
        public static UscSettings load(StreamReader sr, List <String> warnings)
        {
            XmlReader reader = XmlReader.Create(sr);

            UscSettings settings = new UscSettings();

            string script = "";

            // The x prefix means "came directly from XML"
            Dictionary <String, String> xParams = new Dictionary <string, string>();

            // Only read the data inside the UscSettings element.
            reader.ReadToFollowing("UscSettings");
            readAttributes(reader, xParams);
            reader = reader.ReadSubtree();

            // Check the version number
            if (!xParams.ContainsKey("version"))
            {
                warnings.Add("This file has no version number, so it might have been read incorrectly.");
            }
            else if (xParams["version"] != "1")
            {
                warnings.Add("Unrecognized settings file version \"" + xParams["version"] + "\".");
            }

            reader.Read(); // this is needed, otherwise the first tag inside uscSettings doesn't work work (not sure why)

            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Element && reader.Name == "Channels")
                {
                    // We found the Channels tag.

                    // Read the ServosAvailable and ServoPeriod attributes from it in to our collection.
                    readAttributes(reader, xParams);

                    // Make a reader that can only read the stuff inside the Channels tag.
                    var channelsReader = reader.ReadSubtree();

                    // For each Channel tag...
                    while (channelsReader.ReadToFollowing("Channel"))
                    {
                        // Read all the attributes.
                        Dictionary <String, String> xChannel = new Dictionary <string, string>();
                        readAttributes(channelsReader, xChannel);

                        // Transform the attributes in to a ChannelSetting object.
                        ChannelSetting cs = new ChannelSetting();
                        if (assertKey("name", xChannel, warnings))
                        {
                            cs.name = xChannel["name"];
                        }

                        if (assertKey("mode", xChannel, warnings))
                        {
                            switch (xChannel["mode"].ToLower())
                            {
                            case "servomultiplied": cs.mode = ChannelMode.ServoMultiplied; break;

                            case "servo": cs.mode = ChannelMode.Servo; break;

                            case "input": cs.mode = ChannelMode.Input; break;

                            case "output": cs.mode = ChannelMode.Output; break;

                            default: warnings.Add("Invalid mode \"" + xChannel["mode"] + "\"."); break;
                            }
                        }

                        if (assertKey("homemode", xChannel, warnings))
                        {
                            switch (xChannel["homemode"].ToLower())
                            {
                            case "goto": cs.homeMode = HomeMode.Goto; break;

                            case "off": cs.homeMode = HomeMode.Off; break;

                            case "ignore": cs.homeMode = HomeMode.Ignore; break;

                            default: warnings.Add("Invalid homemode \"" + xChannel["homemode"] + "\"."); break;
                            }
                        }

                        if (assertKey("min", xChannel, warnings))
                        {
                            parseU16(xChannel["min"], ref cs.minimum, "min", warnings);
                        }
                        if (assertKey("max", xChannel, warnings))
                        {
                            parseU16(xChannel["max"], ref cs.maximum, "max", warnings);
                        }
                        if (assertKey("home", xChannel, warnings))
                        {
                            parseU16(xChannel["home"], ref cs.home, "home", warnings);
                        }
                        if (assertKey("speed", xChannel, warnings))
                        {
                            parseU16(xChannel["speed"], ref cs.speed, "speed", warnings);
                        }
                        if (assertKey("acceleration", xChannel, warnings))
                        {
                            parseU8(xChannel["acceleration"], ref cs.acceleration, "acceleration", warnings);
                        }
                        if (assertKey("neutral", xChannel, warnings))
                        {
                            parseU16(xChannel["neutral"], ref cs.neutral, "neutral", warnings);
                        }
                        if (assertKey("range", xChannel, warnings))
                        {
                            parseU16(xChannel["range"], ref cs.range, "range", warnings);
                        }

                        settings.channelSettings.Add(cs);
                    }

                    if (channelsReader.ReadToFollowing("Channel"))
                    {
                        warnings.Add("More than " + settings.servoCount + " channel elements were found.  The extra elements have been discarded.");
                    }
                }
                else if (reader.NodeType == XmlNodeType.Element && reader.Name == "Sequences")
                {
                    // We found the Sequences tag.

                    // For each Sequence tag in this sequence...
                    var sequencesReader = reader.ReadSubtree();
                    while (sequencesReader.ReadToFollowing("Sequence"))
                    {
                        // Create a new sequence.
                        Sequence sequence = new Sequence();
                        settings.sequences.Add(sequence);

                        // Read the sequence tag attributes (should just be "name").
                        Dictionary <String, String> sequenceAttributes = new Dictionary <string, string>();
                        readAttributes(sequencesReader, sequenceAttributes);

                        if (sequenceAttributes.ContainsKey("name"))
                        {
                            sequence.name = sequenceAttributes["name"];
                        }
                        else
                        {
                            sequence.name = "Sequence " + settings.sequences.Count;
                            warnings.Add("No name found for sequence " + sequence.name + ".");
                        }

                        // For each frame tag in this sequence...
                        var framesReader = reader.ReadSubtree();
                        while (framesReader.ReadToFollowing("Frame"))
                        {
                            // Create a new frame.
                            Frame frame = new Frame();
                            sequence.frames.Add(frame);

                            // Read the frame attributes from XML (name, duration)
                            Dictionary <String, String> frameAttributes = new Dictionary <string, string>();
                            readAttributes(framesReader, frameAttributes);

                            if (frameAttributes.ContainsKey("name"))
                            {
                                frame.name = frameAttributes["name"];
                            }
                            else
                            {
                                frame.name = "Frame " + sequence.frames.Count;
                                warnings.Add("No name found for " + frame.name + " in sequence \"" + sequence.name + "\".");
                            }

                            if (frameAttributes.ContainsKey("duration"))
                            {
                                parseU16(frameAttributes["duration"], ref frame.length_ms,
                                         "Duration for frame \"" + frame.name + "\" in sequence \"" + sequence.name + "\".", warnings);
                            }
                            else
                            {
                                frame.name = "Frame " + sequence.frames.Count;
                                warnings.Add("No duration found for frame \"" + frame.name + "\" in sequence \"" + sequence.name + "\".");
                            }

                            frame.setTargetsFromString(reader.ReadElementContentAsString(), settings.servoCount);
                        }
                    }
                }
                else if (reader.NodeType == XmlNodeType.Element && reader.Name == "Script")
                {
                    // We found the <Script> tag.

                    // Get the ScriptDone attribute in to our dictionary.
                    readAttributes(reader, xParams);

                    // Read the script.
                    script = reader.ReadElementContentAsString();
                }
                else if (reader.NodeType == XmlNodeType.Element)
                {
                    // Read the miscellaneous parameters that come in element tags, like <NeverSuspend>false</NeverSuspend>.
                    try
                    {
                        xParams[reader.Name] = reader.ReadElementContentAsString();
                    }
                    catch (XmlException e)
                    {
                        warnings.Add("Unable to parse element \"" + reader.Name + "\": " + e.Message);
                    }
                }
            }
            reader.Close();

            //// Step 2: Put the data in to the settings object.

            try
            {
                settings.setAndCompileScript(script);
            }
            catch (Exception e)
            {
                warnings.Add("Error compiling script from XML file: " + e.Message);
                settings.scriptInconsistent = true;
            }

            if (assertKey("NeverSuspend", xParams, warnings))
            {
                parseBool(xParams["NeverSuspend"], ref settings.neverSuspend, "NeverSuspend", warnings);
            }

            if (assertKey("SerialMode", xParams, warnings))
            {
                switch (xParams["SerialMode"])
                {
                default: settings.serialMode = uscSerialMode.SERIAL_MODE_UART_DETECT_BAUD_RATE; break;

                case "UART_FIXED_BAUD_RATE": settings.serialMode = uscSerialMode.SERIAL_MODE_UART_FIXED_BAUD_RATE; break;

                case "USB_DUAL_PORT": settings.serialMode = uscSerialMode.SERIAL_MODE_USB_DUAL_PORT; break;

                case "USB_CHAINED": settings.serialMode = uscSerialMode.SERIAL_MODE_USB_CHAINED; break;
                }
            }

            if (assertKey("FixedBaudRate", xParams, warnings))
            {
                parseU32(xParams["FixedBaudRate"], ref settings.fixedBaudRate, "FixedBaudRate", warnings);
            }

            if (assertKey("SerialTimeout", xParams, warnings))
            {
                parseU16(xParams["SerialTimeout"], ref settings.serialTimeout, "SerialTimeout", warnings);
            }

            if (assertKey("EnableCrc", xParams, warnings))
            {
                parseBool(xParams["EnableCrc"], ref settings.enableCrc, "EnableCrc", warnings);
            }

            if (assertKey("SerialDeviceNumber", xParams, warnings))
            {
                parseU8(xParams["SerialDeviceNumber"], ref settings.serialDeviceNumber, "SerialDeviceNumber", warnings);
            }

            if (assertKey("SerialMiniSscOffset", xParams, warnings))
            {
                parseU8(xParams["SerialMiniSscOffset"], ref settings.miniSscOffset, "SerialMiniSscOffset", warnings);
            }

            if (assertKey("ScriptDone", xParams, warnings))
            {
                parseBool(xParams["ScriptDone"], ref settings.scriptDone, "ScriptDone", warnings);
            }

            // These parameters are optional because they don't apply to all Maestros.
            if (xParams.ContainsKey("ServosAvailable"))
            {
                parseU8(xParams["ServosAvailable"], ref settings.servosAvailable, "ServosAvailable", warnings);
            }

            if (xParams.ContainsKey("ServoPeriod"))
            {
                parseU8(xParams["ServoPeriod"], ref settings.servoPeriod, "ServoPeriod", warnings);
            }

            if (xParams.ContainsKey("EnablePullups"))
            {
                parseBool(xParams["EnablePullups"], ref settings.enablePullups, "EnablePullups", warnings);
            }

            if (xParams.ContainsKey("MiniMaestroServoPeriod"))
            {
                parseU32(xParams["MiniMaestroServoPeriod"], ref settings.miniMaestroServoPeriod, "MiniMaestroServoPeriod", warnings);
            }

            if (xParams.ContainsKey("ServoMultiplier"))
            {
                parseU16(xParams["ServoMultiplier"], ref settings.servoMultiplier, "ServoMultiplier", warnings);
            }

            return(settings);
        }
示例#33
0
        private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
        {
            XmlReaderSettings settings = new XmlReaderSettings();

            settings.IgnoreWhitespace = true;
            chart1.Series[0].Points.Clear();
            chart1.Series[1].Points.Clear();
            chart2.Series[0].Points.Clear();
            chart2.Series[1].Points.Clear();
            chart2.Series[2].Points.Clear();
            listView1.Items.Clear();
            XmlReader reader = XmlReader.Create(Application.StartupPath + "\\stats\\" + listBox1.SelectedItem.ToString() + ".xml", settings);

            if (reader.ReadToFollowing("BrazeNumber"))
            {
                reader.MoveToAttribute(0);
                textBox1.Text = reader.Value;
            }
            if (reader.ReadToFollowing("Date"))
            {
                reader.MoveToAttribute(0);
                textBox2.Text = reader.Value;
            }
            if (reader.ReadToFollowing("Duration"))
            {
                reader.MoveToAttribute(0);
                textBox3.Text = reader.Value;
            }
            if (reader.ReadToFollowing("Status"))
            {
                reader.MoveToAttribute(0);
                textBox5.Text = reader.Value;
            }

            chart2.Titles[0].Text = "Temperatures - Braze # " + textBox1.Text + " " + textBox2.Text;
            chart1.Titles[0].Text = "Pressure - Braze #" + textBox1.Text + " " + textBox2.Text;

            if (reader.ReadToFollowing("Process"))
            {
                if (reader.ReadToDescendant("Log"))
                {
                    reader.MoveToAttribute(0);
                    string value = reader.Value;
                    reader.MoveToAttribute(1);
                    string error = reader.Value;
                    if (error.Equals("True"))
                    {
                        listView1.Items.Add(value).ForeColor = System.Drawing.Color.Red;
                    }
                    else
                    {
                        listView1.Items.Add(value);
                    }
                    while (reader.ReadToNextSibling("Log"))
                    {
                        reader.MoveToAttribute(0);
                        value = reader.Value;
                        reader.MoveToAttribute(1);
                        error = reader.Value;
                        if (error.Equals("True"))
                        {
                            listView1.Items.Add(value).ForeColor = System.Drawing.Color.Red;
                        }
                        else
                        {
                            listView1.Items.Add(value);
                        }
                    }
                }
            }
            if (reader.ReadToFollowing("VacuumPressure"))
            {
                if (reader.ReadToDescendant("Measurement"))
                {
                    reader.MoveToAttribute(0);
                    double value = double.Parse(reader.Value);
                    if (value > 0)
                    {
                        chart1.Series[0].Points.AddY(value);
                    }
                    while (reader.ReadToNextSibling("Measurement"))
                    {
                        reader.MoveToAttribute(0);
                        value = double.Parse(reader.Value);
                        if (value > 0)
                        {
                            chart1.Series[0].Points.AddY(value);
                        }
                    }
                }
            }

            if (reader.ReadToNextSibling("NormalPressure"))
            {
                if (reader.ReadToDescendant("Measurement"))
                {
                    reader.MoveToAttribute(0);
                    double value = double.Parse(reader.Value);
                    if (value > 0)
                    {
                        chart1.Series[1].Points.AddY(value);
                    }
                    while (reader.ReadToNextSibling("Measurement"))
                    {
                        reader.MoveToAttribute(0);
                        value = double.Parse(reader.Value);
                        if (value < 0.1)
                        {
                            value = 0.001;
                        }
                        chart1.Series[1].Points.AddY(value);
                    }
                }
            }

            if (reader.ReadToFollowing("Temp1"))
            {
                if (reader.ReadToDescendant("Measurement"))
                {
                    reader.MoveToAttribute(0);
                    double value = double.Parse(reader.Value);
                    chart2.Series[2].Points.AddY(value);
                    while (reader.ReadToNextSibling("Measurement"))
                    {
                        reader.MoveToAttribute(0);
                        value = double.Parse(reader.Value);
                        chart2.Series[0].Points.AddY(value);
                    }
                }
            }

            if (reader.ReadToFollowing("Temp2"))
            {
                if (reader.ReadToDescendant("Measurement"))
                {
                    reader.MoveToAttribute(0);
                    double value = double.Parse(reader.Value);
                    chart2.Series[1].Points.AddY(value);
                    while (reader.ReadToNextSibling("Measurement"))
                    {
                        reader.MoveToAttribute(0);
                        value = double.Parse(reader.Value);
                        chart2.Series[1].Points.AddY(value);
                    }
                }
            }

            if (reader.ReadToFollowing("Temp3"))
            {
                if (reader.ReadToDescendant("Measurement"))
                {
                    reader.MoveToAttribute(0);
                    double value = double.Parse(reader.Value);
                    chart2.Series[0].Points.AddY(value);
                    while (reader.ReadToNextSibling("Measurement"))
                    {
                        reader.MoveToAttribute(0);
                        value = double.Parse(reader.Value);
                        chart2.Series[2].Points.AddY(value);
                    }
                }
            }

            chart2.ChartAreas[0].AxisY.IsStartedFromZero = false;
            chart2.ChartAreas[0].AxisY.Minimum           = (int)chart2.Series[0].Points[0].YValues[0];
        }
示例#34
0
    private static int[,] loadCollisionLayer(XmlReader mapReader)
    {
        int[,] layer;

        int width = Int32.Parse(mapReader[1]);
        int height = Int32.Parse(mapReader[2]);

        layer = new int[height, width];
        for (int i = 0; i < height * width; i++) {
            mapReader.ReadToFollowing("tile");
            uint col = UInt32.Parse(mapReader[0]);
            if (col != 0)
                layer[i / width, i % width] = (int)col;
            else
                layer[i / width, i % width] = 0;
        }
        return layer;
    }
示例#35
0
        private void ParseJunction(XmlReader r)
        {
            while (r.ReadToFollowing("node"))
            {
                Node node = new Node(r.GetAttribute("name"));

                try {
                    node.Elevation = XmlConvert.ToDouble(r.GetAttribute("elevation") ?? "0");
                }
                catch (ArgumentException) {
                    LogException(ErrorCode.Err202, r.ReadOuterXml());
                }


                try {
                    node.Position = new EnPoint(
                        XmlConvert.ToDouble(r.GetAttribute("x") ?? "0"),
                        XmlConvert.ToDouble(r.GetAttribute("y") ?? "0"));
                }
                catch (ArgumentException) {
                    LogException(ErrorCode.Err202, r.ReadOuterXml());
                }

                using (var rr = r.ReadSubtree()) {
                    rr.Read();
                    while (rr.Read())
                    {
                        switch (rr.NodeType)
                        {
                        case XmlNodeType.Element:

                            if (rr.Name.Equals("demand", StringComparison.Ordinal))
                            {
                                string sx = rr.GetAttribute("base") ?? string.Empty;
                                string sy = rr.GetAttribute("pattern") ?? string.Empty;

                                try {
                                    // cur.Add(XmlConvert.ToDouble(sx), XmlConvert.ToDouble(sy));
                                }
                                catch (FormatException) {
                                    LogException(ErrorCode.Err202, rr.ReadInnerXml());
                                }
                            }

                            break;

                        case XmlNodeType.Comment:
                            node.Comment = rr.Value;
                            break;
                        }
                    }
                }



                try {
                    net.Nodes.Add(node);
                }
                catch (ArgumentException) {
                    LogException(ErrorCode.Err215, node.Name);
                }
            }
        }
示例#36
0
        public override Network Parse(Network nw, string f)
        {
            net = nw ?? new Network();

            XmlReaderSettings settings = new XmlReaderSettings {
                CloseInput       = false,
                ValidationType   = ValidationType.None,
                CheckCharacters  = true,
                IgnoreComments   = false,
                IgnoreWhitespace = true,
            };

            try {
                Stream stream = _gzipped
                    ? (Stream) new GZipStream(File.OpenRead(f), CompressionMode.Decompress)
                    : File.OpenRead(f);

                using (stream) {
                    using (_reader = XmlReader.Create(stream, settings)) {
                        _reader.ReadToFollowing("network");
                        ParsePc(_reader);
                    }

                    stream.Position = 0;

                    using (_reader = XmlReader.Create(stream, settings)) {
                        _reader.ReadToFollowing("network");
                        // this.reader.Read(); // skip "network"
                        // this.reader.MoveToContent(); // If that node is whitespace, skip to content.



                        while (_reader.Read())
                        {
                            if (_reader.NodeType != XmlNodeType.Element || _reader.IsEmptyElement)
                            {
                                continue;
                            }

                            try {
                                _sectionType = (SectType)Enum.Parse(typeof(SectType), _reader.Name, true);
                            }
                            catch (ArgumentException) {
                                continue;
                            }


                            var r = _reader.ReadSubtree();

                            switch (_sectionType)
                            {
                            case SectType.TITLE:
                                ParseTitle(r);
                                break;

                            case SectType.JUNCTIONS:
                                ParseJunction(r);
                                break;

                            case SectType.RESERVOIRS:
                            case SectType.TANKS:
                                ParseTank(r);
                                break;

                            case SectType.PIPES:
                                ParsePipe(r);
                                break;

                            case SectType.PUMPS:
                                ParsePump(r);
                                break;

                            case SectType.VALVES:
                                ParseValve(r);
                                break;

                            case SectType.CONTROLS:
                                ParseControl(r);
                                break;

                            case SectType.RULES:
                                ParseRule(r);
                                break;

                            case SectType.DEMANDS:
                                ParseDemand(r);
                                break;

                            case SectType.SOURCES:
                                ParseSource(r);
                                break;

                            case SectType.EMITTERS:
                                ParseEmitter(r);
                                break;

                            case SectType.QUALITY:
                                ParseQuality(r);
                                break;

                            case SectType.STATUS:
                                ParseStatus(r);
                                break;

                            case SectType.ENERGY:
                                ParseEnergy(r);
                                break;

                            case SectType.REACTIONS:
                                ParseReact(r);
                                break;

                            case SectType.MIXING:
                                ParseMixing(r);
                                break;

                            case SectType.REPORT:
                                ParseReport(r);
                                break;

                            case SectType.TIMES:
                                ParseTime(r);
                                break;

                            case SectType.OPTIONS:
                                ParseOption(r);
                                break;

                            case SectType.COORDINATES:
                                ParseCoordinate(r);
                                break;

                            case SectType.VERTICES:
                                ParseVertice(r);
                                break;

                            case SectType.LABELS:
                                ParseLabel(r);
                                break;
                            }
                        }
                    }
                }
            }
            catch (IOException) {
                throw new ENException(ErrorCode.Err302);
            }

            return(net);
        }
示例#37
0
	protected virtual void LoadStatus (XmlReader reader) {
		reader.ReadToFollowing ("Status");
		reader.ReadToDescendant ("HP");
		HP = reader.ReadElementContentAsInt ();
	}