Svg.Transforms.SvgTransformConverter.SplitTransforms C# (CSharp) Method

        private static IEnumerable<string> SplitTransforms(string transforms)
        {
            int transformEnd = 0;

            for (int i = 0; i < transforms.Length; i++)
            {
                if (transforms[i] == ')')
                {
                    yield return transforms.Substring(transformEnd, i - transformEnd + 1).Trim();
                    transformEnd = i + 1;
                }
            }
        }

        /// <summary>
        /// Converts the given object to the type of this converter, using the specified context and culture information.
        /// </summary>
        /// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext"/> that provides a format context.</param>
        /// <param name="culture">The <see cref="T:System.Globalization.CultureInfo"/> to use as the current culture.</param>
        /// <param name="value">The <see cref="T:System.Object"/> to convert.</param>
        /// <returns>
        /// An <see cref="T:System.Object"/> that represents the converted value.
        /// </returns>
        /// <exception cref="T:System.NotSupportedException">The conversion cannot be performed. </exception>
        public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
        {
            if (value is string)
            {
                SvgTransformCollection transformList = new SvgTransformCollection();

                string[] parts;
                string   contents;
                string   transformName;

                foreach (string transform in SvgTransformConverter.SplitTransforms((string)value))
                {
                    if (string.IsNullOrEmpty(transform))
                    {
                        continue;
                    }

                    parts         = transform.Split('(', ')');
                    transformName = parts[0].Trim();
                    contents      = parts[1].Trim();

                    switch (transformName)
                    {
                    case "translate":
                        string[] coords = contents.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);

                        if (coords.Length == 0 || coords.Length > 2)
                        {
                            throw new FormatException("Translate transforms must be in the format 'translate(x [,y])'");
                        }

                        float x = float.Parse(coords[0].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture);
                        if (coords.Length > 1)
                        {
                            float y = float.Parse(coords[1].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture);
                            transformList.Add(new SvgTranslate(x, y));
                        }
                        else
                        {
                            transformList.Add(new SvgTranslate(x));
                        }
                        break;

                    case "rotate":
                        string[] args = contents.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);

                        if (args.Length != 1 && args.Length != 3)
                        {
                            throw new FormatException("Rotate transforms must be in the format 'rotate(angle [cx cy ])'");
                        }

                        float angle = float.Parse(args[0], NumberStyles.Float, CultureInfo.InvariantCulture);

                        if (args.Length == 1)
                        {
                            transformList.Add(new SvgRotate(angle));
                        }
                        else
                        {
                            float cx = float.Parse(args[1], NumberStyles.Float, CultureInfo.InvariantCulture);
                            float cy = float.Parse(args[2], NumberStyles.Float, CultureInfo.InvariantCulture);

                            transformList.Add(new SvgRotate(angle, cx, cy));
                        }
                        break;

                    case "scale":
                        string[] scales = contents.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);

                        if (scales.Length == 0 || scales.Length > 2)
                        {
                            throw new FormatException("Scale transforms must be in the format 'scale(x [,y])'");
                        }

                        float sx = float.Parse(scales[0].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture);

                        if (scales.Length > 1)
                        {
                            float sy = float.Parse(scales[1].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture);
                            transformList.Add(new SvgScale(sx, sy));
                        }
                        else
                        {
                            transformList.Add(new SvgScale(sx));
                        }

                        break;

                    case "matrix":
                        string[] points = contents.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);

                        if (points.Length != 6)
                        {
                            throw new FormatException("Matrix transforms must be in the format 'matrix(m11, m12, m21, m22, dx, dy)'");
                        }

                        List <float> mPoints = new List <float>();
                        foreach (string point in points)
                        {
                            mPoints.Add(float.Parse(point.Trim(), NumberStyles.Float, CultureInfo.InvariantCulture));
                        }

                        transformList.Add(new SvgMatrix(mPoints));
                        break;

                    case "shear":
                        string[] shears = contents.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);

                        if (shears.Length == 0 || shears.Length > 2)
                        {
                            throw new FormatException("Shear transforms must be in the format 'shear(x [,y])'");
                        }

                        float hx = float.Parse(shears[0].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture);

                        if (shears.Length > 1)
                        {
                            float hy = float.Parse(shears[1].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture);
                            transformList.Add(new SvgShear(hx, hy));
                        }
                        else
                        {
                            transformList.Add(new SvgShear(hx));
                        }

                        break;

                    case "skewX":
                        float ax = float.Parse(contents, NumberStyles.Float, CultureInfo.InvariantCulture);
                        transformList.Add(new SvgSkew(ax, 0));
                        break;

                    case "skewY":
                        float ay = float.Parse(contents, NumberStyles.Float, CultureInfo.InvariantCulture);
                        transformList.Add(new SvgSkew(0, ay));
                        break;
                    }
                }

                return(transformList);
            }

            return(base.ConvertFrom(context, culture, value));
        }