示例#1
0
        /// <summary>
        /// Gets a linear gradient definition.
        /// </summary>
        public static LinearGradientColor GetLinearGradientColor(StructureDescriptor descriptor)
        {
            var linearGradientColor = new LinearGradientColor();

            linearGradientColor.GradientStops = new List <GradientColorStop>();

            linearGradientColor.GradientStops = GetGradientColor(descriptor, linearGradientColor);

            return(linearGradientColor);
        }
        /// <summary>
        /// Get our intermediate linear gradient color definition from the given psd color definition
        /// </summary>
        private (GraphicLinearGradientBrush, GraphicColorPrecision) GetLinearGradientBrush(LinearGradientColor linearGradientColor, double aspectRatio, bool returnDarkDefaultColor)
        {
            var gradient = new GraphicLinearGradientBrush();

            double angle = linearGradientColor.Angle;

            if (linearGradientColor.IsReverse)
            {
                angle += 180;

                if (angle > 180)
                {
                    angle -= 360;
                }
            }

            var    scale        = linearGradientColor.Scale / 100;
            double angleFullAbs = Math.Abs(angle);

            double x2;
            double x1;

            double y2;
            double y1;

            if (angle == 90)
            {
                x1 = 0.5;
                x2 = 0.5;

                y1 = 0.5 + scale * 0.5;
                y2 = 0.5 - scale * 0.5;
            }
            else
            if (angle == -90)
            {
                x1 = 0.5;
                x2 = 0.5;

                y1 = 0.5 - scale * 0.5;
                y2 = 0.5 + scale * 0.5;
            }
            else
            {
                var angleAbs = angleFullAbs;

                if (angleFullAbs > 90)
                {
                    angleAbs = 180 - angleFullAbs;
                }

                double angleRad = angleAbs * Math.PI / 180.0;
                var    beta     = Math.Atan(aspectRatio);

                if (angleRad < beta)
                {
                    var a = 0.5 * Math.Tan(angleRad) * scale;

                    if (angleFullAbs <= 90)
                    {
                        x1 = 0.5 - scale * 0.5;
                        x2 = 0.5 + scale * 0.5;
                    }
                    else
                    {
                        x1 = 0.5 + scale * 0.5;
                        x2 = 0.5 - scale * 0.5;
                    }

                    if (angle >= 0)
                    {
                        y1 = 0.5 + a / aspectRatio;
                        y2 = 0.5 - a / aspectRatio;
                    }
                    else
                    {
                        y1 = 0.5 - a / aspectRatio;
                        y2 = 0.5 + a / aspectRatio;
                    }
                }
                else
                {
                    var a = 0.5 * Math.Tan(Math.PI / 2 - angleRad) * scale;

                    if (angleFullAbs <= 90)
                    {
                        x1 = 0.5 - a * aspectRatio;
                        x2 = 0.5 + a * aspectRatio;
                    }
                    else
                    {
                        x1 = 0.5 + a * aspectRatio;
                        x2 = 0.5 - a * aspectRatio;
                    }

                    if (angle >= 0)
                    {
                        y1 = 0.5 + scale * 0.5;
                        y2 = 0.5 - scale * 0.5;
                    }
                    else
                    {
                        y1 = 0.5 - scale * 0.5;
                        y2 = 0.5 + scale * 0.5;
                    }
                }
            }

            gradient.StartPoint = new Point(x1, y1);
            gradient.EndPoint   = new Point(x2, y2);

            gradient.GradientStops = new List <GraphicGradientStop>();
            GraphicColorPrecision precision;

            foreach (var stop in linearGradientColor.GradientStops)
            {
                var gs = new GraphicGradientStop();
                gradient.GradientStops.Add(gs);

                (gs.Color, precision) = GetColor(stop.Color, returnDarkDefaultColor);
                gs.Position           = stop.Position / linearGradientColor.MaxPosition;
            }

            return(gradient, GraphicColorPrecision.Estimated);
        }