コード例 #1
0
        public override object Clone()
        {
            MemoryStream           stream = new MemoryStream();
            BinaryFormatSerializer binaryFormatSerializer = new BinaryFormatSerializer();

            binaryFormatSerializer.Serialize(this, stream);
            CircularGauge circularGauge = new CircularGauge();

            binaryFormatSerializer.Deserialize(circularGauge, stream);
            return(circularGauge);
        }
コード例 #2
0
        public CircularGauge Add(string name)
        {
            CircularGauge circularGauge = new CircularGauge();

            circularGauge.Name = name;
            circularGauge.Scales.Add(new CircularScale());
            circularGauge.Pointers.Add(new CircularPointer());
            circularGauge.Ranges.Add(new CircularRange());
            this.Add(circularGauge);
            return(circularGauge);
        }
コード例 #3
0
 public void Insert(int index, CircularGauge value)
 {
     base.List.Insert(index, value);
 }
コード例 #4
0
 public bool Contains(CircularGauge value)
 {
     return(base.List.Contains(value));
 }
コード例 #5
0
 public void Remove(CircularGauge value)
 {
     base.List.Remove(value);
 }
コード例 #6
0
 public int Add(CircularGauge value)
 {
     return(base.List.Add(value));
 }
コード例 #7
0
 public int IndexOf(CircularGauge value)
 {
     return(base.List.IndexOf(value));
 }
コード例 #8
0
        private void BuildCircularGaugeAutoFrame(GaugeGraphics g, GraphicsPath path, CircularGauge gauge, float shrinkBy)
        {
            float startAngle = gauge.Scales[0].StartAngle;
            float num        = gauge.Scales[0].StartAngle + gauge.Scales[0].SweepAngle;
            float radius     = gauge.Scales[0].Radius;
            float num2       = gauge.Scales[0].GetLargestRadius(g);

            if (gauge.Scales.Count > 1)
            {
                for (int i = 1; i < gauge.Scales.Count; i++)
                {
                    if (startAngle > gauge.Scales[i].StartAngle)
                    {
                        startAngle = gauge.Scales[i].StartAngle;
                    }
                    if (num < gauge.Scales[i].StartAngle + gauge.Scales[i].SweepAngle)
                    {
                        num = gauge.Scales[i].StartAngle + gauge.Scales[i].SweepAngle;
                    }
                    if (radius < gauge.Scales[i].Radius)
                    {
                        radius = gauge.Scales[i].Radius;
                    }
                    float largestRadius = gauge.Scales[i].GetLargestRadius(g);
                    if (num2 < largestRadius)
                    {
                        num2 = largestRadius;
                    }
                }
            }
            float num3 = 0f;

            foreach (CircularPointer pointer in gauge.Pointers)
            {
                if (pointer.Visible && pointer.Type == CircularPointerType.Needle)
                {
                    float num4 = (float)(pointer.CapWidth / 2.0 * pointer.GetScale().Radius / 100.0);
                    if (pointer.CapVisible && num4 > num3)
                    {
                        num3 = num4;
                    }
                    float num5 = (float)(pointer.GetNeedleTailLength() * pointer.GetScale().Radius / 100.0);
                    if (num5 > num3)
                    {
                        num3 = num5;
                    }
                }
            }
            foreach (Knob knob in gauge.Knobs)
            {
                if (knob.Visible)
                {
                    float num6 = (float)(knob.Width * knob.GetScale().Radius / 100.0);
                    if (num6 > num3)
                    {
                        num3 = num6;
                    }
                }
            }
            num3 = g.GetAbsoluteDimension(num3);
            float absoluteDimension  = g.GetAbsoluteDimension((float)(radius / 5.0));
            float absoluteDimension2 = g.GetAbsoluteDimension((float)(this.FrameWidth * radius / 100.0));
            float absoluteDimension3 = g.GetAbsoluteDimension((float)(shrinkBy * radius / 100.0));

            absoluteDimension += absoluteDimension2;
            absoluteDimension -= absoluteDimension3;
            float  num7               = num - startAngle;
            PointF absolutePoint      = g.GetAbsolutePoint(gauge.PivotPoint);
            float  absoluteDimension4 = g.GetAbsoluteDimension(num2);
            float  num8               = (float)(startAngle * 3.1415927410125732 / 180.0);
            float  num9               = (float)((360.0 - startAngle - num7) * 3.1415927410125732 / 180.0);
            PointF pointF             = default(PointF);

            pointF.X = absolutePoint.X - absoluteDimension4 * (float)Math.Sin((double)num8);
            pointF.Y = absolutePoint.Y + absoluteDimension4 * (float)Math.Cos((double)num8);
            PointF pointF2 = default(PointF);

            pointF2.X = absolutePoint.X + absoluteDimension4 * (float)Math.Sin((double)num9);
            pointF2.Y = absolutePoint.Y + absoluteDimension4 * (float)Math.Cos((double)num9);
            RectangleF rect = new RectangleF(pointF.X, pointF.Y, 0f, 0f);

            rect.Inflate(absoluteDimension, absoluteDimension);
            RectangleF rect2 = new RectangleF(pointF2.X, pointF2.Y, 0f, 0f);

            rect2.Inflate(absoluteDimension, absoluteDimension);
            RectangleF rect3 = new RectangleF(absolutePoint.X, absolutePoint.Y, 0f, 0f);

            rect3.Inflate(absoluteDimension + num3, absoluteDimension + num3);
            RectangleF rect4 = new RectangleF(absolutePoint.X, absolutePoint.Y, 0f, 0f);

            rect4.Inflate(absoluteDimension4 + absoluteDimension, absoluteDimension4 + absoluteDimension);
            if (num7 < 270.0)
            {
                path.AddArc(rect, (float)(startAngle + 270.0 + 90.0), 90f);
                path.AddArc(rect4, (float)(startAngle + 90.0), num7);
                path.AddArc(rect2, (float)(startAngle + num7 + 90.0), 90f);
                path.AddArc(rect3, (float)(startAngle + num7 + 90.0 + 45.0), (float)(360.0 - num7 - 90.0));
            }
            else if (num7 >= 320.0)
            {
                path.AddEllipse(rect4);
            }
            else
            {
                float num10 = (float)(90.0 - (360.0 - num7) / 2.0);
                path.AddArc(rect, (float)(startAngle + 270.0 + 90.0 + num10), (float)(90.0 - num10));
                path.AddArc(rect4, (float)(startAngle + 90.0), num7);
                path.AddArc(rect2, (float)(startAngle + num7 + 90.0), (float)(90.0 - num10));
            }
            path.CloseFigure();
        }
コード例 #9
0
        public GraphicsPath GetFramePath(GaugeGraphics g, float shrinkBy)
        {
            RectangleF frameRectangle    = this.GetFrameRectangle(g);
            float      absoluteDimension = g.GetAbsoluteDimension(shrinkBy);

            frameRectangle.Inflate((float)(0.0 - absoluteDimension), (float)(0.0 - absoluteDimension));
            if (shrinkBy > 0.0)
            {
                frameRectangle.Inflate(1f, 1f);
            }
            if (this.FrameShape == BackFrameShape.Circular)
            {
                GraphicsPath graphicsPath = new GraphicsPath();
                graphicsPath.AddEllipse(frameRectangle);
                return(graphicsPath);
            }
            if (this.FrameShape == BackFrameShape.AutoShape)
            {
                GraphicsPath graphicsPath2 = new GraphicsPath();
                if (this.Parent is CircularGauge)
                {
                    CircularGauge circularGauge = (CircularGauge)this.Parent;
                    if (circularGauge.Scales.Count == 0)
                    {
                        graphicsPath2.AddEllipse(frameRectangle);
                    }
                    else
                    {
                        this.BuildCircularGaugeAutoFrame(g, graphicsPath2, circularGauge, shrinkBy);
                    }
                }
                else
                {
                    graphicsPath2.AddRectangle(frameRectangle);
                }
                return(graphicsPath2);
            }
            if (this.FrameShape == BackFrameShape.RoundedRectangular)
            {
                float   num   = (!(frameRectangle.Width > frameRectangle.Height)) ? frameRectangle.Width : frameRectangle.Height;
                float   num2  = (float)(num / 8.0);
                float[] array = new float[10];
                for (int i = 0; i < 10; i++)
                {
                    array[i] = num2;
                }
                return(g.CreateRoundedRectPath(frameRectangle, array));
            }
            if (this.FrameShape == BackFrameShape.Rectangular)
            {
                GraphicsPath graphicsPath3 = new GraphicsPath();
                graphicsPath3.AddRectangle(frameRectangle);
                return(graphicsPath3);
            }
            GraphicsPath graphicsPath4 = new GraphicsPath();

            graphicsPath4.FillMode = FillMode.Winding;
            XamlRenderer cachedXamlRenderer = this.GetCachedXamlRenderer(g);

            graphicsPath4.AddPath(cachedXamlRenderer.Layers[0].Paths[0], false);
            return(graphicsPath4);
        }
コード例 #10
0
        public RectangleF GetFrameRectangle(GaugeGraphics g)
        {
            RectangleF result;

            if (this.Parent is GaugeCore)
            {
                result = new RectangleF(0f, 0f, (float)(((GaugeCore)this.Parent).GetWidth() - 1), (float)(((GaugeCore)this.Parent).GetHeight() - 1));
            }
            else
            {
                if ((this.FrameShape == BackFrameShape.Rectangular || this.FrameShape == BackFrameShape.RoundedRectangular) && this.Parent is CircularGauge)
                {
                    CircularGauge circularGauge = (CircularGauge)this.Parent;
                    if (circularGauge.ParentObject != null)
                    {
                        result = g.GetAbsoluteRectangle(new RectangleF(0f, 0f, 100f, 100f));
                        if (circularGauge.Position.Rectangle.Width > 0.0 && circularGauge.Position.Rectangle.Height > 0.0)
                        {
                            if (!double.IsNaN((double)circularGauge.AspectRatio))
                            {
                                if (circularGauge.AspectRatio >= 1.0)
                                {
                                    float width = result.Width;
                                    result.Width = result.Height * circularGauge.AspectRatio;
                                    result.X    += (float)((width - result.Width) / 2.0);
                                }
                                else
                                {
                                    float height = result.Height;
                                    result.Height = result.Width / circularGauge.AspectRatio;
                                    result.Y     += (float)((height - result.Height) / 2.0);
                                }
                            }
                            else
                            {
                                float num = circularGauge.Position.Rectangle.Width / circularGauge.Position.Rectangle.Height;
                                if (circularGauge.Position.Rectangle.Width > circularGauge.Position.Rectangle.Height)
                                {
                                    float num2 = result.Height * num;
                                    result.X    += (float)((result.Width - num2) / 2.0);
                                    result.Width = num2;
                                }
                                else
                                {
                                    float num3 = result.Width / num;
                                    result.Y     += (float)((result.Height - num3) / 2.0);
                                    result.Height = num3;
                                }
                            }
                        }
                    }
                    else
                    {
                        result = circularGauge.absoluteRect;
                        if (!double.IsNaN((double)circularGauge.AspectRatio))
                        {
                            if (result.Width > result.Height * circularGauge.AspectRatio)
                            {
                                float width2 = result.Width;
                                result.Width = result.Height * circularGauge.AspectRatio;
                                result.X    += (float)((width2 - result.Width) / 2.0);
                            }
                            else
                            {
                                float height2 = result.Height;
                                result.Height = result.Width / circularGauge.AspectRatio;
                                result.Y     += (float)((height2 - result.Height) / 2.0);
                            }
                        }
                        PointF empty = PointF.Empty;
                        empty.X = (float)(0.0 - g.Graphics.Transform.OffsetX + g.InitialOffset.X);
                        empty.Y = (float)(0.0 - g.Graphics.Transform.OffsetY + g.InitialOffset.Y);
                        result.Offset(empty.X, empty.Y);
                    }
                    goto IL_0371;
                }
                result = g.GetAbsoluteRectangle(new RectangleF(0f, 0f, 100f, 100f));
            }
            goto IL_0371;
IL_0371:
            if (this.FrameShape == BackFrameShape.Circular || this.IsCustomXamlFrame())
            {
                if (result.Width > result.Height)
                {
                    result.X    += (float)((result.Width - result.Height) / 2.0);
                    result.Width = result.Height;
                }
                else if (result.Height > result.Width)
                {
                    result.Y     += (float)((result.Height - result.Width) / 2.0);
                    result.Height = result.Width;
                }
            }
            float xamlFrameAspectRatio = BackFrame.GetXamlFrameAspectRatio(this.Shape);

            if (xamlFrameAspectRatio > 1.0)
            {
                float num4 = result.Height * xamlFrameAspectRatio;
                result.X    += (float)((result.Width - num4) / 2.0);
                result.Width = num4;
            }
            else if (xamlFrameAspectRatio < 1.0)
            {
                float num5 = result.Width / xamlFrameAspectRatio;
                result.Y     += (float)((result.Height - num5) / 2.0);
                result.Height = num5;
            }
            if (this.Parent is GaugeCore)
            {
                if (this.ShadowOffset < 0.0)
                {
                    result.X      -= this.ShadowOffset;
                    result.Y      -= this.ShadowOffset;
                    result.Width  += this.ShadowOffset;
                    result.Height += this.ShadowOffset;
                }
                else if (this.ShadowOffset > 0.0)
                {
                    result.Width  -= this.ShadowOffset;
                    result.Height -= this.ShadowOffset;
                }
            }
            return(result);
        }