public virtual void Transform(IAxis axis, IEnumerable<IAxis> dependentAxes)
 {
     foreach (var ax in dependentAxes)
     {
         Transform(axis, ax);
     }
 }

        public void Draw(Chart2DSpriteContainer sprites, IAxis axis1, IAxis axis2, Vector2 offset)
        {
            if (this.HorizontalLines != null)
                foreach (var line in this.HorizontalLines)
                    line.Draw(sprites, axis1, axis2, offset, Vector2.UnitX, Vector2.UnitY);

            if (this.VerticalLines != null)
                foreach (var line in this.VerticalLines)
                    line.Draw(sprites, axis2, axis1, offset, Vector2.UnitY, Vector2.UnitX);
        }

        void mInput_AxisAdded(IAxis axis)
        {
            AxisPanel panel = new AxisPanel(axis, AxisBinding.MouseX, AxisBinding.MouseY);
            panel.Anchor = AnchorStyles.Left | AnchorStyles.Right;
            panel.Width = axesBox.Width - PADDING * 2;
            axesBox.Controls.Add(panel);
            panel.SizeChanged += new EventHandler(panel_SizeChanged);

            RepositionPanels();
        }

        void mPlugin_AxisAdded(IAxis axis)
        {
            AxisPanel panel = new AxisPanel(axis, AxisBinding.X, AxisBinding.Y, AxisBinding.Z, AxisBinding.Pitch, AxisBinding.Yaw, AxisBinding.Z);
            panel.Anchor = AnchorStyles.Left | AnchorStyles.Right;
            panel.Width = axesBox.Width - PADDING * 2;
            axesBox.Controls.Add(panel);
            panel.SizeChanged += new EventHandler(panel_SizeChanged);

            RepositionPanels();
        }

        private void mAxis_AxisAdded(IAxis axis)
        {
            positivePulldown.Items.Add(axis);
            negativePulldown.Items.Add(axis);

            if (axis == mAxis.Positive)
                positivePulldown.SelectedItem = axis;
            if (axis == mAxis.Negative)
                negativePulldown.SelectedItem = axis;
        }

 /// <summary>
 /// Retrieves the value for a given access from a data point.
 /// </summary>
 /// <param name="dataPoint">The data point to retrieve the value from.</param>
 /// <param name="axis">The axis to retrieve the value for.</param>
 /// <returns>A function that returns a value appropriate for the axis
 /// when provided a DataPoint.</returns>
 protected virtual object GetActualDataPointAxisValue(DataPoint dataPoint, IAxis axis)
 {
     if (axis == InternalActualIndependentAxis)
     {
         return dataPoint.ActualIndependentValue;
     }
     else if (axis == InternalActualDependentAxis)
     {
         return dataPoint.ActualDependentValue;
     }
     return null;
 }

 /// <summary>
 /// Returns the actual margin for a given framework element and axis.
 /// </summary>
 /// <param name="element">The framework element.</param>
 /// <param name="axis">The axis along which to return the margin.
 /// </param>
 /// <returns>The margin for a given framework element and axis.
 /// </returns>
 public static double GetActualMargin(this FrameworkElement element, IAxis axis)
 {
     double length = 0.0;
     if (axis.Orientation == AxisOrientation.X)
     {
         length = element.ActualWidth;
     }
     else if (axis.Orientation == AxisOrientation.Y)
     {
         length = element.ActualHeight;
     }
     return length / 2.0;
 }

        public void ConfigureAxis(IAxis axis, Core core)
        {
            if (core != null && axis is ITickListener)
                (axis as ITickListener).Init(core);

            if (axis is ConstrainedAxis) {
                ConstrainedAxis ax = axis as ConstrainedAxis;
                ax.Deadzone.Value = GetDeadzone(axis.Name);
                ax.Scale.Value  = GetScale(axis.Name);
            }
            if (axis.Binding == AxisBinding.NotSet)
                axis.Binding = GetBinding(axis.Name);
        }

 /// <summary>
 /// Returns the margin for a given framework element and axis.
 /// </summary>
 /// <param name="element">The framework element.</param>
 /// <param name="axis">The axis along which to return the margin.
 /// </param>
 /// <returns>The margin for a given framework element and axis.
 /// </returns>
 public static double GetMargin(this FrameworkElement element, IAxis axis)
 {
     double length = 0.0;
     if (axis.Orientation == AxisOrientation.X)
     {
         length = !double.IsNaN(element.Width) ? element.Width : element.ActualWidth;
     }
     else if (axis.Orientation == AxisOrientation.Y)
     {
         length = !double.IsNaN(element.Height) ? element.Height : element.ActualHeight;
     }
     return length / 2.0;
 }

        private void UpdateVerticalTicks(IAxis axis)
        {
            axisGrid.BeginTicksUpdate();

            if (axis != null)
            {
                axisGrid.VerticalTicks = axis.ScreenTicks;
                axisGrid.MinorVerticalTicks = axis.MinorScreenTicks;
            }
            else
            {
                axisGrid.VerticalTicks = null;
                axisGrid.MinorHorizontalTicks = null;
            }

            axisGrid.EndTicksUpdate();
        }

 /// <summary>
 /// Constructs a new vertical CRS.
 /// </summary>
 /// <param name="name">The name of the CRS.</param>
 /// <param name="datum">The datum the CRS is based on.</param>
 /// <param name="linearUnit">The linear unit for the CRS.</param>
 /// <param name="axis">The axis for the linear CRS.</param>
 /// <param name="authority">The authority.</param>
 public OgcCrsVertical(
     string name,
     IDatum datum,
     IUnit linearUnit,
     IAxis axis,
     IAuthorityTag authority
     )
     : base(name, authority)
 {
     if(datum == null) throw new ArgumentNullException("datum");
     if(linearUnit == null) throw new ArgumentNullException("linearUnit");
     if(axis == null) throw new ArgumentNullException("axis");
     Contract.Requires(name != null);
     Datum = datum;
     Unit = linearUnit;
     Axis = axis;
 }

        public AxisPanel(IAxis axis, params AxisBinding[] ignoredBindings)
            : this(ignoredBindings)
        {
            mAxis = axis;

            bindingDropdown.SelectedItem = axis.Binding;
            mainGroup.Text = axis.Name;

            UserControl control = mAxis.ControlPanel;

            mExpandedSize = MinimumSize.Height + control.Height;
            Height = editBox.Checked ? mExpandedSize : MinimumSize.Height;

            control.Visible = editBox.Checked;
            control.Width = configPanel.Width;
            control.Dock = DockStyle.Fill;
            //control.Anchor = AnchorStyles.Left | AnchorStyles.Right | AnchorStyles.Top;
            configPanel.Controls.Add(control);
        }

        public void Draw(Chart2DSpriteContainer sprites, IAxis parallelAxis, IAxis perpendicularAxis,
            Vector2 offset, Vector2 direction, Vector2 axisUnit)
        {
            sprites.Color = this.color;

            var minOffset = offset + direction * (float)parallelAxis.DataToChart(parallelAxis.MinValue);
            var maxOffset = offset + direction * (float)parallelAxis.DataToChart(parallelAxis.MaxValue);

            int minI = this.repeat ? (int)((perpendicularAxis.MinValue - this.StartValue) / this.interval) : 0;
            int maxI = this.repeat ? (int)((perpendicularAxis.MaxValue - this.StartValue) / this.interval) : 0;

            for (int i = minI; i <= maxI; i++)
            {
                var position = axisUnit * (float)perpendicularAxis.DataToChart(this.StartValue + this.interval * i);

                sprites.DrawLine(
                    minOffset + position,
                    maxOffset + position,
                    sprites.ThinLineWidth);
            }
        }

 private void UpdateVerticalTicks(IAxis axis)
 {
     if (axis != null)
     {
         axisGrid.VerticalTicks = axis.ScreenTicks;
     }
     else
     {
         axisGrid.VerticalTicks = null;
     }
 }

 /// <summary>
 /// IndependentAxisProperty property changed handler.
 /// </summary>
 /// <param name="newValue">New value.</param>
 private void OnIndependentAxisPropertyChanged(IAxis newValue)
 {
     this.InternalIndependentAxis = (IAxis)newValue;
 }

        /// <summary>
        /// Gets the margin to use for an independent axis that does not implement ICategoryAxis.
        /// </summary>
        /// <param name="axis">Axis to get the margin for.</param>
        /// <returns>Margin for axis.</returns>
        private double GetMarginForNonCategoryAxis(IAxis axis)
        {
            Debug.Assert(!(axis is ICategoryAxis), "This method is unnecessary for ICategoryAxis.");

            // Find the smallest distance between two independent value plot area coordinates
            double smallestDistance = double.MaxValue;
            double lastCoordinate = double.NaN;
            foreach (double coordinate in
                IndependentValueGroupsOrderedByIndependentValue
                    .Select(g => axis.GetPlotAreaCoordinate(g.IndependentValue).Value)
                    .Where(v => ValueHelper.CanGraph(v)))
            {
                if (!double.IsNaN(lastCoordinate))
                {
                    double distance = coordinate - lastCoordinate;
                    if (distance < smallestDistance)
                    {
                        smallestDistance = distance;
                    }
                }
                lastCoordinate = coordinate;
            }
            // Return the margin
            if (double.MaxValue == smallestDistance)
            {
                // No smallest distance because <= 1 independent values to plot
                FrameworkElement element = axis as FrameworkElement;
                if (null != element)
                {
                    // Use width of provided axis so single column scenario looks good
                    return element.GetMargin(axis);
                }
                else
                {
                    // No information to work with; no idea what margin to return
                    throw new NotSupportedException();
                }
            }
            else
            {
                // Found the smallest distance; margin is half of that
                return smallestDistance / 2;
            }
        }

 /// <summary>
 /// Notifies the specified axis of changes to values plotting against it.
 /// </summary>
 /// <param name="axis">Specified axis.</param>
 protected void NotifyAxisValuesChanged(IAxis axis)
 {
     if (null != axis)
     {
         IRangeConsumer rangeConsumer = axis as IRangeConsumer;
         if (null != rangeConsumer)
         {
             IRangeProvider rangeProvider = (IRangeProvider)this;
             rangeConsumer.RangeChanged(rangeProvider, new Range<IComparable>() /*rangeProvider.GetRange(rangeConsumer)*/);
         }
         IDataConsumer dataConsumer = axis as IDataConsumer;
         if (null != dataConsumer)
         {
             IDataProvider dataProvider = (IDataProvider)this;
             dataConsumer.DataChanged(dataProvider, null /*dataProvider.GetData(dataConsumer)*/);
         }
     }
 }

 /// <summary>
 /// Notifies the specified axis of changes to value margins plotting against it.
 /// </summary>
 /// <param name="axis">Specified axis.</param>
 /// <param name="valueMargins">Sequence of value margins that have changed.</param>
 protected void NotifyValueMarginsChanged(IAxis axis, IEnumerable<ValueMargin> valueMargins)
 {
     if (null != axis)
     {
         IValueMarginConsumer valueMarginConsumer = axis as IValueMarginConsumer;
         if (null != valueMarginConsumer)
         {
             IValueMarginProvider valueMarginProvider = (IValueMarginProvider)this;
             valueMarginConsumer.ValueMarginsChanged(valueMarginProvider, valueMargins);
         }
     }
 }

 /// <summary>
 /// Handles notification of the invalidation of an axis.
 /// </summary>
 /// <param name="axis">Invalidated axis.</param>
 void IAxisListener.AxisInvalidated(IAxis axis)
 {
     QueueUpdateDataItemPlacement(false, false, DataItems);
 }

 private void OnIndependentAxisChanged(IAxis oldValue, IAxis newValue)
 {
     if (null != ActualIndependentAxis)
     {
         EnsureAxes(false, true, false);
     }
 }