コード例 #1
0
 object[] GetItems(Renderer2D rend, AxisCanvas ax)
 {
     if (rend != null)
     {
         if (rend.Inverted)
         {
             if (ax == _ay)
             {
                 return(rend.ItemNames);
             }
         }
         else if (ax == _ax)
         {
             return(rend.ItemNames);
         }
     }
     return(null);
 }
コード例 #2
0
        internal RenderContext(IRenderer renderer, IDataSeriesInfo ds, int npts)
        {
            _cur          = new Point();
            _prev         = new Point();
            _curView      = new Point();
            _bounds       = new Rect();
            _stacked      = new List <double>();
            _excludeHoles = true;
            _pts          = new List <Point>();
            _rect         = Extensions.EmptyRect;
            _clipBounds   = Extensions.EmptyRect;
            _rendrerer    = renderer;
            _ds           = ds;
            _pts.Capacity = npts;
            if (_ds != null)
            {
                _names = _ds.GetDataNames();
            }
            Chart visual = renderer.Visual as Chart;

            Chart = visual;
            BaseRenderer renderer2 = renderer as BaseRenderer;

            _isStacked = (renderer2 != null) && renderer2.IsStacked;
            hasNan     = renderer2._dataInfo.hasNaN;
            DataSeries series = ds as DataSeries;

            if (series != null)
            {
                Renderer2D rendererd = renderer as Renderer2D;
                if ((((byte)(series.Display & SeriesDisplay.ShowNaNGap)) != 0) && (rendererd != null))
                {
                    _excludeHoles = false;
                }
                if (rendererd != null)
                {
                    string axisX = series.AxisX;
                    string axisY = series.AxisY;
                    bool   flag  = !string.IsNullOrEmpty(axisX);
                    bool   flag2 = !string.IsNullOrEmpty(axisY);
                    if (visual != null)
                    {
                        ChartViewport2D viewElement = visual.View.Viewport;
                        if (viewElement != null)
                        {
                            if (flag || flag2)
                            {
                                foreach (Axis axis in viewElement.Axes)
                                {
                                    if (flag && (axis.AxisName == axisX))
                                    {
                                        _ax    = axis;
                                        hasNan = true;
                                    }
                                    if (flag2 && (axis.AxisName == axisY))
                                    {
                                        _ay    = axis;
                                        hasNan = true;
                                    }
                                }
                            }
                            _defax = viewElement._ax;
                            _defay = viewElement._ay;
                        }
                    }
                }
            }
            if (visual.View != null)
            {
                ChartView view = visual.View;
                if (_ax != null)
                {
                    XReversed = _ax.ReversedInternal;
                }
                else if (visual.View.AxisX != null)
                {
                    XReversed = visual.View.AxisX.Reversed;
                }
                if (_ay != null)
                {
                    YReversed = _ay.ReversedInternal;
                }
                else if (visual.View.AxisY != null)
                {
                    YReversed = visual.View.AxisY.Reversed;
                }
                Axis axis2 = visual.View.GetAxisX(series);
                if ((axis2 != null) && !double.IsNaN(axis2.LogBase))
                {
                    hasNan = true;
                }
                Axis axis3 = visual.View.GetAxisY(series);
                if ((axis3 != null) && !double.IsNaN(axis3.LogBase))
                {
                    hasNan = true;
                }
                if ((renderer2 != null) && renderer2.Inverted)
                {
                    if ((axis2 != null) && (axis2.PlotAreaIndex != 0))
                    {
                        ClusterPlotAreaIndex = axis2.PlotAreaIndex;
                    }
                }
                else if ((axis3 != null) && (axis3.PlotAreaIndex != 0))
                {
                    ClusterPlotAreaIndex = axis3.PlotAreaIndex;
                }
            }
        }
コード例 #3
0
        void PrepareAxes()
        {
            Renderer2D renderer = _view.Renderer as Renderer2D;
            int        num      = _axes.Count;

            for (int i = 0; i < num; i++)
            {
                Axis axis = _axes[i];
                if ((axis != _ax) && (axis != _ay))
                {
                    Point min = new Point(double.NaN, double.NaN);
                    Point max = new Point(double.NaN, double.NaN);
                    if (renderer != null)
                    {
                        foreach (DataSeries series in renderer.Series)
                        {
                            bool flag  = series.AxisX == axis.AxisName;
                            bool flag2 = series.AxisY == axis.AxisName;
                            if (flag || flag2)
                            {
                                series.GetMinMax(ref min, ref max);
                            }
                        }
                        if (renderer.Inverted)
                        {
                            double x = min.X;
                            min.X = min.Y;
                            min.Y = x;
                            x     = max.X;
                            max.X = max.Y;
                            max.Y = x;
                        }
                    }
                    switch (axis.AxisType)
                    {
                    case AxisType.X:
                        axis.SetLimitsAux(min.X, max.X);
                        break;

                    case AxisType.Y:
                        axis.SetLimitsAux(min.Y, max.Y);
                        break;
                    }
                }
                axis.RoundLimits();
                if (axis.Axis.IsDependent)
                {
                    double scale = 1.0;
                    double num5  = 0.0;
                    Func <double, double> dependentAxisConverter = axis.Axis.DependentAxisConverter;
                    if (axis.AxisType == AxisType.X)
                    {
                        if (dependentAxisConverter != null)
                        {
                            double num6 = dependentAxisConverter(_ax.Min0);
                            double num7 = dependentAxisConverter(_ax.Max0);
                            if (num6 <= num7)
                            {
                                axis.Min0 = axis._min = num6;
                                axis.Max0 = axis._max = num7;
                            }
                            else
                            {
                                axis.Min0 = axis._min = num7;
                                axis.Max0 = axis._max = num6;
                            }
                        }
                        else
                        {
                            axis.Min0 = axis._min = _ax.Min0;
                            axis.Max0 = axis._max = _ax.Max0;
                        }
                        num5  = _ax.Axis.Value;
                        scale = _ax.Axis.Scale;
                    }
                    else if (axis.AxisType == AxisType.Y)
                    {
                        if (dependentAxisConverter != null)
                        {
                            double num8 = dependentAxisConverter(_ay.Min0);
                            double num9 = dependentAxisConverter(_ay.Max0);
                            if (num8 <= num9)
                            {
                                axis.Min0 = axis._min = num8;
                                axis.Max0 = axis._max = num9;
                            }
                            else
                            {
                                axis.Min0 = axis._min = num9;
                                axis.Max0 = axis._max = num8;
                            }
                        }
                        else
                        {
                            axis.Min0 = axis._min = _ay.Min0;
                            axis.Max0 = axis._max = _ay.Max0;
                        }
                        num5  = _ay.Axis.Value;
                        scale = _ay.Axis.Scale;
                    }
                    if (scale < 1.0)
                    {
                        double num10 = (axis.Max0 - axis.Min0) * scale;
                        axis._min = axis.Min0 + (num5 * ((axis.Max0 - axis.Min0) - num10));
                        axis._max = axis._min + num10;
                    }
                }
                axis.ClearLabelsAndTicks();
            }
        }
コード例 #4
0
        void PerformPlotAreaLayout()
        {
            List <AreaDef> list  = new List <AreaDef>();
            List <AreaDef> list2 = new List <AreaDef>();
            int            num   = _view.Axes.Count;

            for (int i = 0; i < num; i++)
            {
                Axis axis = _view.Axes[i];
                if (axis.AxisType == AxisType.X)
                {
                    while (list.Count <= axis.PlotAreaIndex)
                    {
                        list.Add(new AreaDef());
                    }
                    list[axis.PlotAreaIndex].Axes.Add(axis);
                }
                else if (axis.AxisType == AxisType.Y)
                {
                    while (list2.Count <= axis.PlotAreaIndex)
                    {
                        list2.Add(new AreaDef());
                    }
                    list2[axis.PlotAreaIndex].Axes.Add(axis);
                }
            }
            int        ncols    = list.Count;
            int        nrows    = list2.Count;
            Renderer2D renderer = _view.Renderer as Renderer2D;
            Size       size     = new Size(CurrentSize.Width, 0.3 * CurrentSize.Height);
            Size       size2    = new Size(CurrentSize.Height, 0.3 * CurrentSize.Width);
            double     left     = 0.0;
            double     top      = 0.0;
            double     width    = CurrentSize.Width;
            double     height   = CurrentSize.Height;

            for (int j = 0; j < ncols; j++)
            {
                AreaDef def = list[j];
                def.Right  = CurrentSize.Width;
                def.Bottom = CurrentSize.Height;
                for (int num10 = 0; num10 < def.Axes.Count; num10++)
                {
                    AxisCanvas iax   = def.Axes[num10].iax as AxisCanvas;
                    Size       size3 = iax.GetSize(GetItems(renderer, iax), false);
                    if (size3.Height > size.Height)
                    {
                        size3.Height = size.Height;
                    }
                    size3.Width     = size.Width;
                    iax.DesiredSize = size3;
                    if (j == 0)
                    {
                        def.Left = Math.Max(def.Left, iax.AnnoSize.Width * 0.5);
                    }
                    if (j == (ncols - 1))
                    {
                        def.Right = Math.Min(def.Right, CurrentSize.Width - (iax.AnnoSize.Width * 0.5));
                    }
                    if (iax.IsNear)
                    {
                        def.Bottom -= size3.Height;
                    }
                    else if (iax.IsFar)
                    {
                        def.Top += size3.Height;
                    }
                }
            }
            for (int k = 0; k < nrows; k++)
            {
                AreaDef def2 = list2[k];
                def2.Right  = CurrentSize.Width;
                def2.Bottom = CurrentSize.Height;
                for (int num12 = 0; num12 < def2.Axes.Count; num12++)
                {
                    AxisCanvas ax    = def2.Axes[num12].iax as AxisCanvas;
                    Size       size4 = ax.GetSize(GetItems(renderer, ax), false);
                    if (size4.Height > size2.Height)
                    {
                        size4.Height = size2.Height;
                    }
                    size4.Width    = size2.Width;
                    ax.DesiredSize = size4;
                    if (k == 0)
                    {
                        def2.Top = Math.Max(def2.Top, ax.AnnoSize.Width * 0.5);
                    }
                    if (k == (nrows - 1))
                    {
                        def2.Bottom = Math.Min(def2.Bottom, CurrentSize.Height - (ax.AnnoSize.Width * 0.5));
                    }
                    if (ax.IsNear)
                    {
                        def2.Left += size4.Height;
                    }
                    else if (ax.IsFar)
                    {
                        def2.Right -= size4.Height;
                    }
                }
            }
            double num13 = 0.0;
            double num14 = 0.0;
            double num15 = CurrentSize.Width;
            double num16 = CurrentSize.Height;

            for (int m = 0; m < ncols; m++)
            {
                AreaDef def3 = list[m];
                num13 = Math.Max(num13, def3.Left);
                num14 = Math.Max(num14, def3.Top);
                num15 = Math.Min(num15, def3.Right);
                num16 = Math.Min(num16, def3.Bottom);
            }
            for (int n = 0; n < nrows; n++)
            {
                AreaDef def4 = list2[n];
                num13 = Math.Max(num13, def4.Left);
                num14 = Math.Max(num14, def4.Top);
                num15 = Math.Min(num15, def4.Right);
                num16 = Math.Min(num16, def4.Bottom);
            }
            double w = 0.0;
            double h = 0.0;

            AdjustMargins(ref left, ref width, ref top, ref height, ref w, ref h, ref num13, ref num15, ref num14, ref num16);
            _plot = _plot0 = new Rect(left, top, w, h);
            double x = left;

            double[] numArray = _view.PlotAreas.CalculateWidths(w, ncols);
            int      num22    = InternalChildren.Count - 1;

            for (int num23 = 0; num23 < ncols; num23++)
            {
                num16 = height;
                num14 = top;
                AreaDef def5  = list[num23];
                double  num24 = numArray[num23];
                for (int num25 = 0; num25 < def5.Axes.Count; num25++)
                {
                    AxisCanvas canvas3 = def5.Axes[num25].iax as AxisCanvas;
                    canvas3._plot = new Rect(x, _plot0.Top, num24, _plot0.Height);
                    Rect r = new Rect();
                    if (canvas3.IsNear)
                    {
                        r      = new Rect(x, num16, num24, canvas3.DesiredSize.Height);
                        num16 += canvas3.DesiredSize.Height;
                    }
                    else if (canvas3.IsFar)
                    {
                        r      = new Rect(x, num14 - canvas3.DesiredSize.Height, num24, canvas3.DesiredSize.Height);
                        num14 -= canvas3.DesiredSize.Height;
                    }
                    canvas3.Layout(r);
                    if (((canvas3 == _ax) && (renderer != null)) && !renderer.Inverted)
                    {
                        canvas3.CreateLabels(renderer.ItemNames);
                    }
                    else
                    {
                        canvas3.CreateLabels(null);
                    }
                    canvas3.CreateAnnosAndTicks(false);
                }
                foreach (PlotArea area in _view.PlotAreas)
                {
                    if (area.Column == num23)
                    {
                        area.SetPlotX(x, num24);
                    }
                }
                x += num24;
            }
            double y = height;

            double[] numArray2 = _view.PlotAreas.CalculateHeights(h, nrows);
            for (int num27 = 0; num27 < nrows; num27++)
            {
                num13 = left;
                num15 = width;
                AreaDef def6  = list2[num27];
                double  num28 = numArray2[num27];
                y -= num28;
                for (int num29 = 0; num29 < def6.Axes.Count; num29++)
                {
                    AxisCanvas canvas4 = def6.Axes[num29].iax as AxisCanvas;
                    canvas4._plot = new Rect(_plot0.Left, y, _plot0.Width, num28);
                    Rect rect2 = new Rect();
                    if (canvas4.IsNear)
                    {
                        rect2  = new Rect(num13 - canvas4.DesiredSize.Height, y, num28, canvas4.DesiredSize.Height);
                        num13 -= canvas4.DesiredSize.Height;
                    }
                    else if (canvas4.IsFar)
                    {
                        rect2  = new Rect(num15, y, num28, canvas4.DesiredSize.Height);
                        num15 += canvas4.DesiredSize.Height;
                    }
                    canvas4.Layout(rect2);
                    if (((canvas4 == _ay) && (renderer != null)) && renderer.Inverted)
                    {
                        canvas4.CreateLabels(renderer.ItemNames);
                    }
                    else
                    {
                        canvas4.CreateLabels(null);
                    }
                    canvas4.CreateAnnosAndTicks(false);
                }
                foreach (PlotArea area2 in _view.PlotAreas)
                {
                    if (area2.Row == num27)
                    {
                        area2.SetPlotY(y, num28);
                    }
                }
            }
            using (IEnumerator <PlotArea> enumerator = _view.PlotAreas.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    UIElement uIElement = enumerator.Current.UIElement;
                    if ((uIElement != null) && !InternalChildren.Contains(uIElement))
                    {
                        InternalChildren.Insert(num22++, uIElement);
                    }
                }
            }
        }
コード例 #5
0
        internal void Refresh()
        {
            if (CurrentSize.Width == 0 || CurrentSize.Height == 0)
            {
                return;
            }

            _ax.Axis = _view.AxisX;
            _ay.Axis = _view.AxisY;
            List <string> list = new List <string>();

            foreach (Axis axis in _axes)
            {
                if ((axis.PositionInternal & AxisPosition.OverData) > AxisPosition.Near)
                {
                    Canvas.SetZIndex(axis, 1);
                }
                else
                {
                    Canvas.SetZIndex(axis, 0);
                }
                ((IAxis)axis).ClearLabels();
                axis.ResetLimits();
                axis.Chart = _view.Chart;
                if (((axis != _ax) && (axis != _ay)) && !string.IsNullOrEmpty(axis.AxisName))
                {
                    list.Add(axis.AxisName);
                }
            }

            if (_view.Renderer != null)
            {
                IView2DRenderer renderer = _view.Renderer as IView2DRenderer;
                if (renderer == null)
                {
                    return;
                }

                _ast = renderer.Axis;
                Size       sz        = new Size(CurrentSize.Width, CurrentSize.Height);
                Renderer2D rendererd = renderer as Renderer2D;
                if (rendererd != null)
                {
                    rendererd.ValidAuxAxes = list.ToArray();
                    if (_plot.Width > 0.0)
                    {
                        sz.Width = _plot.Width;
                    }
                    if (_plot.Height > 0.0)
                    {
                        sz.Height = _plot.Height;
                    }
                }

                Rect rect = renderer.Measure(sz);
                if (rect.Width > 0.0)
                {
                    _ax.SetLimits(rect.X, rect.X + rect.Width);
                }
                if (rect.Height > 0.0)
                {
                    _ay.SetLimits(rect.Y, rect.Y + rect.Height);
                }
            }

            switch (_ast)
            {
            case AxisStyle.None:
                if ((base.Width > 10.0) && (base.Height > 10.0))
                {
                    _plot = new Rect(5.0, 5.0, base.Width - 10.0, base.Height - 10.0);
                }
                using (List <Axis> .Enumerator enumerator3 = _axes.GetEnumerator())
                {
                    while (enumerator3.MoveNext())
                    {
                        enumerator3.Current.Visibility = Utils.VisHidden;
                    }
                }
                break;

            case AxisStyle.Cartesian:
                UpdateLayoutCartesian();
                break;

            case AxisStyle.Radar:
                using (List <Axis> .Enumerator enumerator2 = _axes.GetEnumerator())
                {
                    while (enumerator2.MoveNext())
                    {
                        enumerator2.Current.Visibility = Visibility.Collapsed;
                    }
                }
                UpdateLayoutRadar();
                break;
            }

            Shape plotShape = _view.PlotShape;

            if (plotShape != null)
            {
                Canvas.SetLeft(plotShape, _view.PlotRect.Left);
                Canvas.SetTop(plotShape, _view.PlotRect.Top);
                plotShape.Width  = _view.PlotRect.Width;
                plotShape.Height = _view.PlotRect.Height;
                if (_ast == AxisStyle.None)
                {
                    plotShape.Visibility = Visibility.Collapsed;
                }
                else
                {
                    plotShape.Visibility = Visibility.Visible;
                }
            }

            if (_view.Chart.UpdateCount <= 0 && _view.Renderer != null)
            {
                CreateDataObjects();
                _view.Renderer.Dirty = false;
            }
        }
コード例 #6
0
        void UpdateLayoutCartesian()
        {
            PrepareAxes();
            if (_view.HasPlotAreas)
            {
                PerformPlotAreaLayout();
                return;
            }

            int        num      = _axes.Count;
            PlotArea   area     = _view.UpdateMainPlotArea();
            Renderer2D renderer = _view.Renderer as Renderer2D;
            double     xLeft    = 0.0;
            double     xTop     = 0.0;
            double     yLeft    = 0.0;
            double     yTop     = 0.0;
            double     width    = CurrentSize.Width;
            double     height   = CurrentSize.Height;
            double     right    = CurrentSize.Width;
            double     bottom   = CurrentSize.Height;

            for (int i = 0; i < num; i++)
            {
                Axis   ax     = _axes[i];
                double origin = ax.Axis.Origin;
                if (ax.AxisType == AxisType.X)
                {
                    Size size  = new Size(CurrentSize.Width, 0.3 * CurrentSize.Height);
                    Size size3 = ax.GetSize(GetItems(renderer, ax), false);
                    if (size3.Height > size.Height)
                    {
                        size3.Height = size.Height;
                    }
                    size3.Width    = size.Width;
                    ax.DesiredSize = size3;
                    bool flag2 = (!double.IsNaN(origin) && (origin <= _ay.Max0)) && (origin >= _ay.Min0);
                    if (ax.IsNear)
                    {
                        xLeft = Math.Max(xLeft, ax.AnnoSize.Width * 0.5);
                        width = Math.Min(width, CurrentSize.Width - (ax.AnnoSize.Width * 0.5));
                        if (flag2)
                        {
                            double num12 = ConvertY(origin, xTop, bottom);
                            bottom -= Math.Max((double)0.0, (double)((num12 + size3.Height) - bottom));
                        }
                        else
                        {
                            bottom -= size3.Height;
                        }
                    }
                    else if (ax.IsFar)
                    {
                        xLeft = Math.Max(xLeft, ax.AnnoSize.Width * 0.5);
                        width = Math.Min(width, CurrentSize.Width - (ax.AnnoSize.Width * 0.5));
                        if (flag2)
                        {
                            double num13 = ConvertY(origin, xTop, bottom);
                            xTop += Math.Max((double)0.0, (double)(xTop - (num13 - size3.Height)));
                        }
                        else
                        {
                            xTop += size3.Height;
                        }
                    }
                }
                else if (ax.AxisType == AxisType.Y)
                {
                    Size size2 = new Size(CurrentSize.Height, 0.3 * CurrentSize.Width);
                    Size size4 = ax.GetSize(GetItems(renderer, ax), false);
                    if (size4.Height > size2.Height)
                    {
                        size4.Height = size2.Height;
                    }
                    size4.Width    = size2.Width;
                    ax.DesiredSize = size4;
                    bool flag3 = (!double.IsNaN(origin) && (origin <= _ax.Max0)) && (origin >= _ax.Min0);
                    if (ax.IsNear)
                    {
                        yTop   = Math.Max(yTop, ax.AnnoSize.Width * 0.5);
                        height = Math.Min(height, CurrentSize.Height - (ax.AnnoSize.Width * 0.5));
                        if (flag3)
                        {
                            double num14 = ConvertX(origin, yLeft, right);
                            yLeft += Math.Max((double)0.0, (double)(yLeft - (num14 - size4.Height)));
                        }
                        else
                        {
                            yLeft += size4.Height;
                        }
                    }
                    else if (ax.IsFar)
                    {
                        yTop   = Math.Max(yTop, ax.AnnoSize.Width * 0.5);
                        height = Math.Min(height, CurrentSize.Height - (ax.AnnoSize.Width * 0.5));
                        if (flag3)
                        {
                            double num15 = ConvertX(origin, yLeft, right);
                            right -= Math.Max((double)0.0, (double)((num15 + size4.Height) - right));
                        }
                        else
                        {
                            right -= size4.Height;
                        }
                    }
                }
            }

            double w = 0.0;
            double h = 0.0;

            AdjustMargins(ref xLeft, ref width, ref yTop, ref height, ref w, ref h, ref yLeft, ref right, ref xTop, ref bottom);
            _plot = _plot0 = new Rect(xLeft, yTop, w, h);
            if (area != null)
            {
                area.SetPlotX(_plot.X, _plot.Width);
                area.SetPlotY(_plot.Y, _plot.Height);
                UIElement uIElement = area.UIElement;
                if ((uIElement != null) && !InternalChildren.Contains(uIElement))
                {
                    InternalChildren.Insert(0, uIElement);
                }
            }

            for (int j = 0; j < num; j++)
            {
                Axis axis2 = _axes[j];
                axis2._plot = _plot0;
                double d = axis2.Axis.Origin;
                if (axis2.AxisType == AxisType.X)
                {
                    Rect r = new Rect();
                    if ((double.IsNaN(d) || (d > _ay.Max0)) || (d < _ay.Min0))
                    {
                        if (axis2.IsNear)
                        {
                            r       = new Rect(xLeft, bottom, w, axis2.DesiredSize.Height);
                            bottom += axis2.DesiredSize.Height;
                        }
                        else if (axis2.IsFar)
                        {
                            r     = new Rect(xLeft, xTop - axis2.DesiredSize.Height, w, axis2.DesiredSize.Height);
                            xTop -= axis2.DesiredSize.Height;
                        }
                    }
                    else
                    {
                        double y = ConvertY(d, _plot.Top, _plot.Bottom);
                        if (axis2.IsNear)
                        {
                            r       = new Rect(xLeft, y, w, axis2.DesiredSize.Height);
                            bottom += Math.Max((double)0.0, (double)(r.Bottom - _plot.Bottom));
                        }
                        else if (axis2.IsFar)
                        {
                            r     = new Rect(xLeft, y - axis2.DesiredSize.Height, w, axis2.DesiredSize.Height);
                            xTop -= Math.Max((double)0.0, (double)(_plot.Top - r.Top));
                        }
                    }
                    axis2.Layout(r);
                }
                else if (axis2.AxisType == AxisType.Y)
                {
                    Rect rect2 = new Rect();
                    if ((double.IsNaN(d) || (d > _ax.Max0)) || (d < _ax.Min0))
                    {
                        if (axis2.IsNear)
                        {
                            rect2  = new Rect(yLeft - axis2.DesiredSize.Height, yTop, h, axis2.DesiredSize.Height);
                            yLeft -= axis2.DesiredSize.Height;
                        }
                        else if (axis2.IsFar)
                        {
                            rect2  = new Rect(right, yTop, h, axis2.DesiredSize.Height);
                            right += axis2.DesiredSize.Height;
                        }
                    }
                    else
                    {
                        double x = ConvertX(d, _plot.Left, _plot.Right);
                        if (axis2.IsNear)
                        {
                            rect2  = new Rect(x - axis2.DesiredSize.Height, yTop, h, axis2.DesiredSize.Height);
                            yLeft -= axis2.DesiredSize.Height;
                        }
                        else if (axis2.IsFar)
                        {
                            rect2  = new Rect(x, yTop, h, axis2.DesiredSize.Height);
                            right += axis2.DesiredSize.Height;
                        }
                    }
                    axis2.Layout(rect2);
                }
                if (((axis2 == _ax) && (renderer != null)) && !renderer.Inverted)
                {
                    axis2.CreateLabels(renderer.ItemNames);
                }
                else if (((axis2 == _ay) && (renderer != null)) && renderer.Inverted)
                {
                    axis2.CreateLabels(renderer.ItemNames);
                }
                else
                {
                    axis2.CreateLabels(null);
                }
                axis2.CreateAnnosAndTicks(false);
            }
        }