private static PlotModel RangeColorAxis(AxisPosition position)
        {
            int n = 1000;
            var model = new PlotModel
            {
                Title = string.Format("ScatterSeries and RangeColorAxis (n={0})", n),
                Background = OxyColors.LightGray
            };

            model.Axes.Add(new LinearAxis { Position = AxisPosition.Bottom });
            model.Axes.Add(new LinearAxis { Position = AxisPosition.Left });

            var rca = new RangeColorAxis { Position = position, Maximum = 2, Minimum = -2 };
            rca.AddRange(0, 0.5, OxyColors.Blue);
            rca.AddRange(-0.2, -0.1, OxyColors.Red);
            model.Axes.Add(rca);

            var s1 = new ScatterSeries { MarkerType = MarkerType.Square, MarkerSize = 6, };

            var random = new Random(13);
            for (int i = 0; i < n; i++)
            {
                double x = (random.NextDouble() * 2.2) - 1.1;
                s1.Points.Add(new ScatterPoint(x, random.NextDouble()) { Value = x });
            }

            model.Series.Add(s1);
            return model;
        }

 public Axis(AxisPosition pos, double minimum, double maximum)
     : this()
 {
     Position = pos;
     Minimum = minimum;
     Maximum = maximum;
 }

 public LogarithmicAxis(AxisPosition position, string title = null, double minimum = double.NaN, double maximum = double.NaN)
     : this()
 {
     this.Position = position;
     this.Title = title;
     this.Minimum = minimum;
     this.Maximum = maximum;
 }

 private static PlotModel CreateRandomScatterSeriesWithColorAxisPlotModel(int n, OxyPalette palette, MarkerType markerType, AxisPosition colorAxisPosition, OxyColor highColor, OxyColor lowColor)
 {
     var model = new PlotModel { Title = string.Format("ScatterSeries (n={0})", n), Background = OxyColors.LightGray };
     var colorAxis = new LinearColorAxis { Position = colorAxisPosition, Palette = palette, Minimum = -1, Maximum = 1, HighColor = highColor, LowColor = lowColor };
     model.Axes.Add(colorAxis);
     model.Series.Add(CreateRandomScatterSeries(n, markerType, false, true, colorAxis));
     return model;
 }

 public LinearAxis(AxisPosition position, double minimum, double maximum, double majorStep, double minorStep, string title = null)
     : this(position, title)
 {
     this.Minimum = minimum;
     this.Maximum = maximum;
     this.MajorStep = majorStep;
     this.MinorStep = minorStep;
 }

 public TimeSpanAxis(
     AxisPosition position,
     double minimum,
     double maximum = double.NaN,
     string title = null,
     string format = "m:ss")
     : base(position, minimum, maximum, title)
 {
     this.StringFormat = format;
 }

        /// <summary>
        /// Creates an instance of YSeriesAxis.
        /// </summary>
        /// <param name="chart"></param>
        /// <param name="series"></param>
        /// <param name="position"></param>
        public YSeriesAxis(C1Chart chart, DataSeries series, AxisPosition position)
            : base(chart, series)
        {
            AxisType = AxisType.Y;
            Position = position;

            if ((position & AxisPosition.Far) > 0)
                AnnoAngle = 90;
            else
                AnnoAngle = -90;

            MinorTickHeight = 0;
        }

        public DateTimeAxis(
            AxisPosition position,
            string title = null,
            string format = null,
            DateTimeIntervalType intervalType = DateTimeIntervalType.Auto)
            : base(position, title)
        {
            this.FirstDayOfWeek = DayOfWeek.Monday;
            this.CalendarWeekRule = CalendarWeekRule.FirstFourDayWeek;

            this.StringFormat = format;
            this.IntervalType = intervalType;
        }

        public static PlotModel CreateRandomScatterSeriesWithColorAxisPlotModel(int n, OxyPalette palette, MarkerType markerType = MarkerType.Square, AxisPosition colorAxisPosition = AxisPosition.Right, OxyColor highColor = null, OxyColor lowColor = null)
        {
            var model = new PlotModel(string.Format("ScatterSeries (n={0})", n)) { Background = OxyColors.LightGray };
            model.Axes.Add(new ColorAxis { Position = colorAxisPosition, Palette = palette, Minimum = -1, Maximum = 1, HighColor = highColor, LowColor = lowColor });

            var s1 = new ScatterSeries
            {
                MarkerType = markerType,
                MarkerSize = 6,
            };
            var random = new Random();
            for (int i = 0; i < n; i++)
            {
                double x = random.NextDouble() * 2.2 - 1.1;
                s1.Points.Add(new ScatterPoint(x, random.NextDouble()) { Value = x });
            }

            model.Series.Add(s1);
            return model;
        }

        private void createAxis(long id, AxisPosition pos)
        {
            ctCatAx = chart.GetCTChart().plotArea.AddNewCatAx();
            ctCatAx.AddNewAxId().val = (uint)id;
            ctCatAx.AddNewAxPos();
            ctCatAx.AddNewScaling();
            ctCatAx.AddNewCrosses();
            ctCatAx.AddNewCrossAx();
            ctCatAx.AddNewTickLblPos().val = ST_TickLblPos.nextTo;
            ctCatAx.AddNewDelete();
            ctCatAx.AddNewMajorTickMark();
            ctCatAx.AddNewMinorTickMark();

            
            this.SetPosition(pos);
            this.SetOrientation(AxisOrientation.MinToMax);
            this.SetCrosses(AxisCrosses.AutoZero);
            this.IsVisible = true;
            this.SetMajorTickMark(AxisTickMark.Cross);
            this.SetMinorTickMark(AxisTickMark.None);
        }

 int MeasureAxisSize(AxisPosition pos)
 {
     int max = 0;
     foreach (Axis ax in axis)
         if (ax.Position == pos && ax.ShowLabels) {
             int nmax = MeasureAxisSize (ax);
             if (nmax > max) max = nmax;
         }
     return max;
 }

        void DrawTicks(Gdk.Window win, Gdk.GC gc, TickEnumerator e, AxisPosition pos, AxisDimension ad, int tickSize, bool showLabels)
        {
            int rwidth, rheight;
            win.GetSize (out rwidth, out rheight);

            Pango.Layout layout = null;

            if (showLabels) {
                layout = new Pango.Layout (this.PangoContext);
                layout.FontDescription = Pango.FontDescription.FromString ("Tahoma 8");
            }

            bool isX = pos == AxisPosition.Top || pos == AxisPosition.Bottom;
            bool isTop = pos == AxisPosition.Top || pos == AxisPosition.Right;

            double start = GetStart (ad);
            double end = GetEnd (ad);

            e.Init (GetOrigin (ad));

            while (e.CurrentValue > start)
                e.MovePrevious ();

            int lastPosLabel;
            int lastPos;
            int lastTw = 0;

            if (isX) {
                lastPosLabel = reverseXAxis ? left + width + MinLabelGapX : left - MinLabelGapX;
                lastPos = left - minTickStep*2;
            }
            else {
                lastPosLabel = reverseYAxis ? top - MinLabelGapY : rheight + MinLabelGapY;
                lastPos = top + height + minTickStep*2;
            }

            for ( ; e.CurrentValue <= end; e.MoveNext ())
            {
                int px, py;
                int tw = 0, th = 0;
                int tick = tickSize;

                GetPoint (e.CurrentValue, e.CurrentValue, out px, out py);

                if (showLabels) {
                    layout.SetMarkup (e.CurrentLabel);
                    layout.GetPixelSize (out tw, out th);
                }

                if (isX) {
                    if (Math.Abs ((long)px - (long)lastPos) < minTickStep || px < left || px > left + width)
                        continue;
                    lastPos = px;

                    bool labelFits = false;
                    if ((Math.Abs (px - lastPosLabel) - (tw/2) - (lastTw/2)) >= MinLabelGapX) {
                        lastPosLabel = px;
                        lastTw = tw;
                        labelFits = true;
                    }

                    if (isTop) {
                        if (showLabels) {
                            if (labelFits)
                                win.DrawLayout (gc, px - (tw/2), top - AreaBorderWidth - th, layout);
                            else
                                tick = tick / 2;
                        }
                        win.DrawLine (gc, px, top, px, top + tick);
                    }
                    else {
                        if (showLabels) {
                            if (labelFits)
                                win.DrawLayout (gc, px - (tw/2), top + height + AreaBorderWidth, layout);
                            else
                                tick = tick / 2;
                        }
                        win.DrawLine (gc, px, top + height, px, top + height - tick);
                    }
                }
                else {
                    if (Math.Abs ((long)lastPos - (long)py) < minTickStep || py < top || py > top + height)
                        continue;
                    lastPos = py;

                    bool labelFits = false;
                    if ((Math.Abs (py - lastPosLabel) - (th/2) - (lastTw/2)) >= MinLabelGapY) {
                        lastPosLabel = py;
                        lastTw = th;
                        labelFits = true;
                    }

                    if (isTop) {
                        if (showLabels) {
                            if (labelFits)
                                win.DrawLayout (gc, left + width + AreaBorderWidth + 1, py - (th/2), layout);
                            else
                                tick = tick / 2;
                        }
                        win.DrawLine (gc, left + width, py, left + width - tick, py);
//.........这里部分代码省略.........

 public void AddAxis(Axis ax, AxisPosition position)
 {
     ax.Owner = this;
     ax.Position = position;
     axis.Add (ax);
     QueueDraw ();
 }

 public IChartAxis CreateCategoryAxis(AxisPosition pos)
 {
     long id = axis.Count + 1;
     XSSFCategoryAxis categoryAxis = new XSSFCategoryAxis(this, id, pos);
     if (axis.Count == 1)
     {
         IChartAxis ax = axis[0];
         ax.CrossAxis(categoryAxis);
         categoryAxis.CrossAxis(ax);
     }
     axis.Add(categoryAxis);
     return categoryAxis;
 }

 public IValueAxis CreateValueAxis(AxisPosition pos)
 {
     long id = axis.Count + 1;
     XSSFValueAxis valueAxis = new XSSFValueAxis(this, id, pos);
     if (axis.Count == 1)
     {
         IChartAxis ax = axis[0];
         ax.CrossAxis(valueAxis);
         valueAxis.CrossAxis(ax);
     }
     axis.Add(valueAxis);
     return valueAxis;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="DateTimeAxis" /> class.
 /// </summary>
 /// <param name="pos">The position of the axis.</param>
 /// <param name="firstDateTime">The first date/time on the axis.</param>
 /// <param name="lastDateTime">The last date/time on the axis.</param>
 /// <param name="title">The axis title.</param>
 /// <param name="format">The string format for the axis values.</param>
 /// <param name="intervalType">The interval type.</param>
 public DateTimeAxis(
 AxisPosition pos,
 DateTime firstDateTime,
 DateTime lastDateTime,
 string title = null,
 string format = null,
 DateTimeIntervalType intervalType = DateTimeIntervalType.Auto)
     : this(pos, title, format, intervalType)
 {
     this.Minimum = ToDouble(firstDateTime);
     this.Maximum = ToDouble(lastDateTime);
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="Axis"/> class.
        /// </summary>
        /// <param name="pos">
        /// The position of the axis.
        /// </param>
        /// <param name="minimum">
        /// The minimum value.
        /// </param>
        /// <param name="maximum">
        /// The maximum value.
        /// </param>
        /// <param name="title">
        /// The axis title.
        /// </param>
        protected Axis(AxisPosition pos, double minimum, double maximum, string title = null)
            : this()
        {
            this.Position = pos;
            this.Minimum = minimum;
            this.Maximum = maximum;

            this.AbsoluteMaximum = double.NaN;
            this.AbsoluteMinimum = double.NaN;

            this.Title = title;
        }

        public XSSFValueAxis(XSSFChart chart, long id, AxisPosition pos)
            : base(chart)
        {

            CreateAxis(id, pos);
        }

        public XSSFCategoryAxis(XSSFChart chart, long id, AxisPosition pos)
            : base(chart)
        {

            createAxis(id, pos);
        }

 /// <summary>
 /// Constructor, which defines the world pixel length together with
 /// the y-axis that should be held constant when forcing this 
 /// constraint [the other y-axis only will be moved].
 /// </summary>
 /// <param name="p">The world pixel length</param>
 /// <param name="holdFixedY">The position of this y-axis will be 
 /// held constant. The other y-axis will be moved in order to 
 /// force the constraint.</param>
 public XPixelWorldLength(double p, AxisPosition holdFixedY)
 {
     pWorldLength_ = p;
     holdFixedY_ = holdFixedY;
 }