public override void Render(IRenderContext rc, PlotModel model1)
        {
            PlotModel model = this.PlotModel;

            this.YAxis = ((MapPlotModel)model).GetAxis(this.YKey);
            if (!SeriesVisible || !((IAxis)this.YAxis).AxisVisible)
            {
                return;
            }
            //AjustAxis();
            if (Points.Count == 0)
            {
                return;
            }

            OxyColor limit_color = OxyColors.Red;

            if (Theme != null)
            {
                LineSeriesStyle style = Theme.GetStyle(ThemeMode) as LineSeriesStyle;
                this.Color  = Helper.ConvertColorToOxyColor(style.LineColor);
                limit_color = Helper.ConvertColorToOxyColor(style.AlarmColor);
            }

            rc.ResetClip();
            OxyRect            clippingRect = model.PlotArea;
            List <ScreenPoint> sps          = new List <ScreenPoint>();

            for (int i = 0; i < Points.Count; i++)
            {
                double      x  = this.XAxis.Transform(Points[i].X);
                double      y  = this.YAxis.Transform(Points[i].Y);
                ScreenPoint sp = new ScreenPoint(x, y);
                sps.Add(sp);

                if (LabelVisible)
                {
                    string text = PointLineSeries.FormatValue(Points[i].Y);
                    PointLineSeries.RenderBoxText(rc, ThemeMode, clippingRect, text, TextPadding, sp, TextOffset, Color);
                }
            }

            if (ShowLimit)
            {
                if (LimitValue != Helper.InvalidData)
                {
                    double y     = this.YAxis.Transform(LimitValue);
                    double left  = model.PlotArea.Left;
                    double right = model.PlotArea.Right;

                    if (y >= this.YAxis.ScreenMin.Y && y <= this.YAxis.ScreenMax.Y)
                    {
                        rc.DrawLine(left, y, right, y, new OxyPen(limit_color, 1, LineStyle.Solid, LineJoin.Miter));
                        string limit_text = PointLineSeries.FormatValue(LimitValue);
                        rc.DrawText(new ScreenPoint(left + 10, y - 15), limit_text, limit_color, "Arial");
                    }
                }
            }

            if (Points.Count > 0)
            {
                double x = this.XAxis.Transform(Points[0].X);
                double y = this.YAxis.Transform(YAxis.Minimum) - 2;

                double x1 = this.XAxis.Transform(Points[Points.Count - 1].X);
                double y1 = y;

                ScreenPoint sp  = new ScreenPoint(x, y);
                ScreenPoint sp1 = new ScreenPoint(x1, y1);

                IList <ScreenPoint> poligon = new List <ScreenPoint>();
                poligon.Add(sp);
                foreach (ScreenPoint item in sps)
                {
                    poligon.Add(item);
                }
                poligon.Add(sp1);

                rc.DrawClippedPolygon(clippingRect, poligon, 2, OxyColor.FromAColor(150, Color), OxyColors.Transparent);
                RenderLine(rc, clippingRect, sps, Color, 2, this.LineStyle);
            }
        }
Beispiel #2
0
        public override void Render(IRenderContext rc, PlotModel model1)
        {
            PlotModel model = this.PlotModel;

            this.YAxis = ((MapPlotModel)model).GetAxis(this.YKey);
            if (!SeriesVisible || !((IAxis)this.YAxis).AxisVisible)
            {
                return;
            }
            //AjustAxis();
            if (_pts.Count == 0)
            {
                return;
            }
            OxyColor average_color = OxyColors.Green;
            OxyColor limit_color   = OxyColors.Red;

            if (Theme != null)
            {
                LineSeriesStyle style = Theme.GetStyle(ThemeMode) as LineSeriesStyle;
                this.FillColor = Helper.ConvertColorToOxyColor(style.LineColor);
                average_color  = Helper.ConvertColorToOxyColor(style.AverageColor);
                limit_color    = Helper.ConvertColorToOxyColor(style.AlarmColor);
            }

            rc.ResetClip();
            IAxis   y_axis       = this.YAxis as IAxis;
            OxyRect clippingRect = y_axis.Bound;

            double width = model.PlotArea.Width;

            List <FeatureText> features = new List <FeatureText>();
            //compute offset
            List <string> column_serieses = new List <string>();

            for (int i = 0; i < model1.Series.Count; i++)
            {
                if (model1.Series[i] is PointColumnSeries || (model1.Series[i] is PointLineSeries && ((PointLineSeries)model1.Series[i]).PointLineStyle == ePointLineStyle.Cloumn))
                {
                    column_serieses.Add(((ISeries)model.Series[i]).Id);
                }
            }

            int    column_padding = 3;
            double total_width    = this.XAxis.Transform(1) - this.XAxis.Transform(0);
            double column_width   = this.ColumnWidth;

            if ((this.ColumnWidth + column_padding) * column_serieses.Count > total_width)
            {
                //auto width;
                column_width = (total_width - column_serieses.Count * column_padding) / column_serieses.Count;
            }
            if (column_width < 1)
            {
                column_width = 1;
            }
            int    index = column_serieses.IndexOf(this.Id);
            double total_column_width = column_width * column_serieses.Count + (column_serieses.Count - 1) * column_padding;
            double offset             = 0;

            if (index >= 0)
            {
                offset = index * (column_width + column_padding) - total_column_width / 2 + column_width / 2;;
            }
            for (int i = 0; i < Count; i++)
            {
                double value = double.Parse(this[i].Value);
                double x     = this.XAxis.Transform(this[i].Index) + offset;
                if (value == 0)
                {
                    continue;
                }
                double      y            = this.YAxis.Transform(value);
                ScreenPoint center_point = new ScreenPoint(x, y);

                string text = PointLineSeries.FormatValue(value);
                if (double.Parse(text) == 0)
                {
                    continue;
                }
                features.Add(new FeatureText(text, center_point, new OxySize(10, 10), center_point));

                ScreenPoint left_top  = new ScreenPoint(center_point.X - ColumnWidth / 2, center_point.Y);
                ScreenPoint right_top = new ScreenPoint(center_point.X + ColumnWidth / 2, center_point.Y);

                double      y1           = this.YAxis.Transform(0);
                ScreenPoint right_bottom = new ScreenPoint(right_top.X, y1 - 2);
                ScreenPoint left_bottom  = new ScreenPoint(left_top.X, y1 - 2);

                IList <ScreenPoint> poligon = new List <ScreenPoint>();
                poligon.Add(left_top);
                poligon.Add(right_top);
                poligon.Add(right_bottom);
                poligon.Add(left_bottom);
                rc.DrawClippedPolygon(clippingRect, poligon, 2, FillColor, FillColor);
            }

            if (_is_average && ShowEverage)
            {
                double y     = this.YAxis.Transform(_average);
                double left  = model.PlotArea.Left;
                double right = model.PlotArea.Right;

                rc.DrawLine(left, y, right, y, new OxyPen(average_color, 1, LineStyle.Dash, LineJoin.Miter));
                string average_text = PointLineSeries.FormatValue(_average);
                rc.DrawText(new ScreenPoint(left + 10, y - 15), average_text, average_color, "Arial");
            }

            if (LimitValue != Helper.InvalidData && ShowLimit)
            {
                double y     = this.YAxis.Transform(LimitValue);
                double left  = model.PlotArea.Left;
                double right = model.PlotArea.Right;

                if (y >= this.YAxis.ScreenMin.Y && y <= this.YAxis.ScreenMax.Y)
                {
                    rc.DrawLine(left, y, right, y, new OxyPen(limit_color, 1, LineStyle.Solid, LineJoin.Miter));
                    string limit_text = PointLineSeries.FormatValue(LimitValue);
                    rc.DrawText(new ScreenPoint(left + 10, y - 15), limit_text, limit_color, "Arial");
                }
            }

            if (LabelVisible)
            {
                foreach (FeatureText feature in features)
                {
                    if (double.Parse(feature.Text) == 0)
                    {
                        continue;
                    }
                    PointLineSeries.RenderBoxText(rc, ThemeMode, clippingRect, feature.Text, TextPadding, feature.Position, TextOffset, FillColor, PointLineSeries.BoxPosition.Middle);
                }
            }
        }