protected override bool AcceptShapeTagElement(DefineShape4Tag tag, XElement element)
        {
            switch (element.Name.LocalName)
            {
            case EDGE_BOUNDS_ELEM:
                tag.EdgeBounds = XRect.FromXml(element.Element("Rectangle"));
                break;

            default:
                return(false);
            }
            return(true);
        }
        protected override bool AcceptTagElement(DefineEditTextTag tag, XElement element)
        {
            switch (element.Name.LocalName)
            {
            case SIZE_ELEM:
                tag.Bounds = XRect.FromXml(element.Element("Rectangle"));
                break;

            case COLOR_ELEM:
                tag.TextColor = XColorRGBA.FromXml(element.Element("Color"));
                break;

            default:
                return(false);
            }
            return(true);
        }
Example #3
0
        protected override bool AcceptTagElement(DefineFont3Tag tag, XElement element)
        {
            switch (element.Name.LocalName)
            {
            case "wideKerning":
                tag.HasLayout = true;
                foreach (var xRecord in element.Elements())
                {
                    tag.KerningRecords.Add(XKerningRecord.FromXml(xRecord));
                }
                break;

            case "advance":
                tag.HasLayout = true;
                var advanceIndex = 0;
                foreach (var xAdvance in element.Elements())
                {
                    var xValue = xAdvance.Attribute("value");
                    tag.Glyphs[advanceIndex].Advance = short.Parse(xValue.Value);
                    advanceIndex++;
                }
                break;

            case "bounds":
                tag.HasLayout = true;
                var boundIndex = 0;
                foreach (var xBound in element.Elements())
                {
                    tag.Glyphs[boundIndex].Bounds = XRect.FromXml(xBound);
                    boundIndex++;
                }
                break;

            case "glyphs":
                foreach (var xGlyph in element.Elements())
                {
                    tag.Glyphs.Add(XGlyph.FromXml(xGlyph));
                }
                break;

            default:
                return(false);
            }
            return(true);
        }
Example #4
0
        public SwfFile ReadFromXml(XDocument doc)
        {
            var         root = doc.Root;
            var         file = new SwfFile();
            SwfFileInfo fileInfo;

            if (root == null || root.Name.LocalName != "swf")
            {
                throw new FormatException("Expected swf as root");
            }
            fileInfo.Version = root.RequiredByteAttribute("version");
            if (!Enum.TryParse(root.RequiredAttribute("format"), false, out fileInfo.Format))
            {
                throw new FormatException("Unable to parse file format");
            }

            if (fileInfo.Format == SwfFormat.Unknown)
            {
                throw new FormatException("Unsupported file format");
            }

            fileInfo.FileLength = 0;
            file.FileInfo       = fileInfo;

            var hdr = root.RequiredElement("Header");

            file.Header.FrameRate  = hdr.RequiredDoubleAttribute("framerate");
            file.Header.FrameCount = hdr.RequiredUShortAttribute("frames");
            file.Header.FrameSize  = XRect.FromXml(hdr.RequiredElement("size").Element("Rectangle"));

            var formatterFactory = new TagFormatterFactory(fileInfo.Version);
            var tags             = hdr.RequiredElement("tags");

            foreach (var xTag in tags.Elements())
            {
                var tag       = SwfTagNameMapping.CreateTagByXmlName(xTag.Name.LocalName);
                var formatter = formatterFactory.GetFormatter(tag);
                tag = formatter.ParseTo(xTag, tag);
                file.Tags.Add(tag);
            }
            return(file);
        }
Example #5
0
        protected sealed override bool AcceptTagElement(T tag, XElement element)
        {
            switch (element.Name.LocalName)
            {
            case BOUNDS_ELEM:
                tag.TextBounds = XRect.FromXml(element.Element("Rectangle"));
                break;

            case TRANSFORM_ELEM:
                tag.TextMatrix = XMatrix.FromXml(element.Element(XMatrix.TAG_NAME));
                break;

            case RECORDS_ELEM:
                ReadRecords(tag, element);
                break;

            default:
                return(false);
            }
            return(true);
        }
        protected sealed override bool AcceptTagElement(T tag, XElement element)
        {
            switch (element.Name.LocalName)
            {
            case BOUNDS_ELEM:
                tag.ShapeBounds = XRect.FromXml(element.Element("Rectangle"));
                break;

            case STYLES_ELEM:
                var xStyleList = element.Element("StyleList");
                ReadStyles(tag, xStyleList);
                break;

            case SHAPES_ELEM:
                var xShape = element.Element("Shape");
                ReadShapes(tag, xShape);
                break;

            default:
                return(AcceptShapeTagElement(tag, element));
            }
            return(true);
        }