/// <summary> /// Initializes a new instance of the <see cref="LinearAsOrdinalScale"/> class. /// Default constructor that defines the owner <see cref="Axis"/> /// (containing object) for this new object. /// </summary> /// <param name="owner"> /// The owner, or containing object, of this instance /// </param> public LinearAsOrdinalScale(Axis owner) : base(owner) { }
/// <summary> /// Initializes a new instance of the <see cref="DateScale"/> class. /// The Copy Constructor /// </summary> /// <param name="rhs"> /// The <see cref="DateScale"/> object from which to copy /// </param> /// <param name="owner"> /// The <see cref="Axis"/> object that will own the new instance of <see cref="DateScale"/> /// </param> public DateScale(Scale rhs, Axis owner) : base(rhs, owner) { }
/// <summary> /// The force num tics. /// </summary> /// <param name="axis"> /// The axis. /// </param> /// <param name="numTics"> /// The num tics. /// </param> private void ForceNumTics(Axis axis, int numTics) { if (axis._scale.MaxAuto) { int nTics = axis._scale.CalcNumTics(); if (nTics < numTics) { axis._scale._maxLinearized += axis._scale._majorStep * (numTics - nTics); } } }
/// <summary> /// Draw the specified single bar (an individual "point") of this series to the specified /// <see cref="Graphics"/> device. This method is not as efficient as /// <see cref="DrawBars"/>, which draws the bars for all points. It is intended to be used only for <see cref="BarType.SortedOverlay"/>, which /// requires special handling of each bar. /// </summary> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the PaintEventArgs argument to the Paint() method. /// </param> /// <param name="pane"> /// A reference to the <see cref="GraphPane"/> object that is the parent or owner of this object. /// </param> /// <param name="curve"> /// A <see cref="CurveItem"/> object representing the /// <see cref="Bar"/>'s to be drawn. /// </param> /// <param name="baseAxis"> /// The <see cref="Axis"/> class instance that defines the base (independent) axis for the <see cref="Bar"/> /// </param> /// <param name="valueAxis"> /// The <see cref="Axis"/> class instance that defines the value (dependent) axis for the <see cref="Bar"/> /// </param> /// <param name="pos"> /// The ordinal position of the this bar series (0=first bar, 1=second bar, etc.) in the cluster of bars. /// </param> /// <param name="index"> /// The zero-based index number for the single bar to be drawn. /// </param> /// <param name="barWidth"> /// The width of each bar, in pixels. /// </param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and passed down by the parent <see cref="GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust font sizes, etc. according to the actual size of the graph. /// </param> public void DrawSingleBar( Graphics g, GraphPane pane, CurveItem curve, Axis baseAxis, Axis valueAxis, int pos, int index, float barWidth, float scaleFactor) { // Make sure that a bar value exists for the current curve and current ordinal position if (index >= curve.Points.Count) { return; } // For Overlay and Stack bars, the position is always zero since the bars are on top // of eachother if (pane._barSettings.Type == BarType.Overlay || pane._barSettings.Type == BarType.Stack || pane._barSettings.Type == BarType.PercentStack) { pos = 0; } // Draw the specified bar this.DrawSingleBar(g, pane, curve, index, pos, baseAxis, valueAxis, barWidth, scaleFactor); }
/// <summary> /// Create a new clone of the current item, with a new owner assignment /// </summary> /// <param name="owner"> /// The new <see cref="Axis"/> instance that will be the owner of the new Scale /// </param> /// <returns> /// A new <see cref="Scale"/> clone. /// </returns> public override Scale Clone(Axis owner) { return new DateScale(this, owner); }
/* /// <summary> /// Use the MouseCaptureChanged as an indicator for the start and end of a scrolling operation /// </summary> private void ScrollBarMouseCaptureChanged( object sender, EventArgs e ) { return; ScrollBar scrollBar = sender as ScrollBar; if ( scrollBar != null ) { // If this is the start of a new scroll, then Capture will be true if ( scrollBar.Capture ) { // save the original zoomstate //_zoomState = new ZoomState( this.GraphPane, ZoomState.StateType.Scroll ); ZoomStateSave( this.GraphPane, ZoomState.StateType.Scroll ); } else { // push the prior saved zoomstate, since the scale ranges have already been changed on // the fly during the scrolling operation if ( _zoomState != null && _zoomState.IsChanged( this.GraphPane ) ) { //this.GraphPane.ZoomStack.Push( _zoomState ); ZoomStatePush( this.GraphPane ); // Provide Callback to notify the user of pan events if ( this.ScrollDoneEvent != null ) this.ScrollDoneEvent( this, scrollBar, _zoomState, new ZoomState( this.GraphPane, ZoomState.StateType.Scroll ) ); _zoomState = null; } } } } */ /// <summary> /// The handle scroll. /// </summary> /// <param name="axis"> /// The axis. /// </param> /// <param name="newValue"> /// The new value. /// </param> /// <param name="scrollMin"> /// The scroll min. /// </param> /// <param name="scrollMax"> /// The scroll max. /// </param> /// <param name="largeChange"> /// The large change. /// </param> /// <param name="reverse"> /// The reverse. /// </param> private void HandleScroll(Axis axis, int newValue, double scrollMin, double scrollMax, int largeChange, bool reverse) { if (axis != null) { if (scrollMin > axis._scale._min) { scrollMin = axis._scale._min; } if (scrollMax < axis._scale._max) { scrollMax = axis._scale._max; } int span = _ScrollControlSpan - largeChange; if (span <= 0) { return; } if (reverse) { newValue = span - newValue; } Scale scale = axis._scale; double delta = scale._maxLinearized - scale._minLinearized; double scrollMin2 = scale.Linearize(scrollMax) - delta; scrollMin = scale.Linearize(scrollMin); // scrollMax = scale.Linearize( scrollMax ); double val = scrollMin + newValue / (double)span * (scrollMin2 - scrollMin); scale._minLinearized = val; scale._maxLinearized = val + delta; /* if ( axis.Scale.IsLog ) { double ratio = axis._scale._max / axis._scale._min; double scrollMin2 = scrollMax / ratio; double val = scrollMin * Math.Exp( (double)newValue / (double)span * ( Math.Logger( scrollMin2 ) - Math.Logger( scrollMin ) ) ); axis._scale._min = val; axis._scale._max = val * ratio; } else { double delta = axis._scale._max - axis._scale._min; double scrollMin2 = scrollMax - delta; double val = scrollMin + (double)newValue / (double)span * ( scrollMin2 - scrollMin ); axis._scale._min = val; axis._scale._max = val + delta; } */ this.Invalidate(); } }
/// <summary> /// The synchronize. /// </summary> /// <param name="source"> /// The source. /// </param> /// <param name="dest"> /// The dest. /// </param> private void Synchronize(Axis source, Axis dest) { dest._scale._min = source._scale._min; dest._scale._max = source._scale._max; dest._scale._majorStep = source._scale._majorStep; dest._scale._minorStep = source._scale._minorStep; dest._scale._minAuto = source._scale._minAuto; dest._scale._maxAuto = source._scale._maxAuto; dest._scale._majorStepAuto = source._scale._majorStepAuto; dest._scale._minorStepAuto = source._scale._minorStepAuto; }
/// <summary> /// Initializes a new instance of the <see cref="Scale"/> class. /// Basic constructor -- requires that the <see cref="Scale"/> object be intialized with a pre-existing owner <see cref="Axis"/>. /// </summary> /// <param name="ownerAxis"> /// The <see cref="Axis"/> object that is the owner of this /// <see cref="Scale"/> instance. /// </param> public Scale(Axis ownerAxis) { this._ownerAxis = ownerAxis; this._min = 0.0; this._max = 1.0; this._majorStep = 0.1; this._minorStep = 0.1; this._exponent = 1.0; this._mag = 0; this._baseTic = PointPairBase.Missing; this._minGrace = Default.MinGrace; this._maxGrace = Default.MaxGrace; this._minAuto = true; this._maxAuto = true; this._majorStepAuto = true; this._minorStepAuto = true; this._magAuto = true; this._formatAuto = true; this._isReverse = Default.IsReverse; this._isUseTenPower = true; this._isPreventLabelOverlap = true; this._isVisible = true; this._isSkipFirstLabel = false; this._isSkipLastLabel = false; this._isSkipCrossLabel = false; this._majorUnit = DateUnit.Day; this._minorUnit = DateUnit.Day; this._format = null; this._textLabels = null; this._isLabelsInside = Default.IsLabelsInside; this._align = Default.Align; this._alignH = Default.AlignH; this._fontSpec = new FontSpec( Default.FontFamily, Default.FontSize, Default.FontColor, Default.FontBold, Default.FontUnderline, Default.FontItalic, Default.FillColor, Default.FillBrush, Default.FillType); this._fontSpec.Border.IsVisible = false; this._labelGap = Default.LabelGap; }
/// <summary> /// Initializes a new instance of the <see cref="Scale"/> class. /// Copy Constructor. Create a new <see cref="Scale"/> object based on the specified existing one. /// </summary> /// <param name="rhs"> /// The <see cref="Scale"/> object to be copied. /// </param> /// <param name="owner"> /// The <see cref="Axis"/> object that will own the new instance of <see cref="Scale"/> /// </param> public Scale(Scale rhs, Axis owner) { this._ownerAxis = owner; this._min = rhs._min; this._max = rhs._max; this._majorStep = rhs._majorStep; this._minorStep = rhs._minorStep; this._exponent = rhs._exponent; this._baseTic = rhs._baseTic; this._minAuto = rhs._minAuto; this._maxAuto = rhs._maxAuto; this._majorStepAuto = rhs._majorStepAuto; this._minorStepAuto = rhs._minorStepAuto; this._magAuto = rhs._magAuto; this._formatAuto = rhs._formatAuto; this._minGrace = rhs._minGrace; this._maxGrace = rhs._maxGrace; this._mag = rhs._mag; this._isUseTenPower = rhs._isUseTenPower; this._isReverse = rhs._isReverse; this._isPreventLabelOverlap = rhs._isPreventLabelOverlap; this._isVisible = rhs._isVisible; this._isSkipFirstLabel = rhs._isSkipFirstLabel; this._isSkipLastLabel = rhs._isSkipLastLabel; this._isSkipCrossLabel = rhs._isSkipCrossLabel; this._majorUnit = rhs._majorUnit; this._minorUnit = rhs._minorUnit; this._format = rhs._format; this._isLabelsInside = rhs._isLabelsInside; this._align = rhs._align; this._alignH = rhs._alignH; this._fontSpec = rhs._fontSpec.Clone(); this._labelGap = rhs._labelGap; if (rhs._textLabels != null) { this._textLabels = (string[])rhs._textLabels.Clone(); } else { this._textLabels = null; } }
/// <summary> /// Setup some temporary transform values in preparation for rendering the /// <see cref="Axis"/>. /// </summary> /// <remarks> /// This method is typically called by the parent <see cref="GraphPane"/> /// object as part of the <see cref="GraphPane.Draw"/> method. It is also called by <see cref="GraphPane.GeneralTransform(double,double,CoordType)"/> /// and /// <see cref="GraphPane.ReverseTransform( PointF, out double, out double )"/> /// methods to setup for coordinate transformations. /// </remarks> /// <param name="pane"> /// A reference to the <see cref="GraphPane"/> object that is the parent or owner of this object. /// </param> /// <param name="axis"> /// The parent <see cref="Axis"/> for this <see cref="Scale"/> /// </param> public virtual void SetupScaleData(GraphPane pane, Axis axis) { // save the ChartRect data for transforming scale values to pixels if (axis is XAxis || axis is X2Axis) { this._minPix = pane.Chart._rect.Left; this._maxPix = pane.Chart._rect.Right; } else { this._minPix = pane.Chart._rect.Top; this._maxPix = pane.Chart._rect.Bottom; } this._minLinTemp = this.Linearize(this._min); this._maxLinTemp = this.Linearize(this._max); }
/// <summary> /// Define suitable default ranges for an axis in the event that no data were available /// </summary> /// <param name="pane"> /// The <see cref="GraphPane"/> of interest /// </param> /// <param name="axis"> /// The <see cref="Axis"/> for which to set the range /// </param> internal void SetRange(GraphPane pane, Axis axis) { if (this._rangeMin >= double.MaxValue || this._rangeMax <= double.MinValue) { // If this is a Y axis, and the main Y axis is valid, use it for defaults if (axis != pane.XAxis && axis != pane.X2Axis && pane.YAxis.Scale._rangeMin < double.MaxValue && pane.YAxis.Scale._rangeMax > double.MinValue) { this._rangeMin = pane.YAxis.Scale._rangeMin; this._rangeMax = pane.YAxis.Scale._rangeMax; } // Otherwise, if this is a Y axis, and the main Y2 axis is valid, use it for defaults else if (axis != pane.XAxis && axis != pane.X2Axis && pane.Y2Axis.Scale._rangeMin < double.MaxValue && pane.Y2Axis.Scale._rangeMax > double.MinValue) { this._rangeMin = pane.Y2Axis.Scale._rangeMin; this._rangeMax = pane.Y2Axis.Scale._rangeMax; } // Otherwise, just use 0 and 1 else { this._rangeMin = 0; this._rangeMax = 1; } } /* if ( yMinVal >= Double.MaxValue || yMaxVal <= Double.MinValue ) { if ( y2MinVal < Double.MaxValue && y2MaxVal > Double.MinValue ) { yMinVal = y2MinVal; yMaxVal = y2MaxVal; } else { yMinVal = 0; yMaxVal = 0.01; } } if ( y2MinVal >= Double.MaxValue || y2MaxVal <= Double.MinValue ) { if ( yMinVal < Double.MaxValue && yMaxVal > Double.MinValue ) { y2MinVal = yMinVal; y2MaxVal = yMaxVal; } else { y2MinVal = 0; y2MaxVal = 1; } } */ }
/// <summary> /// Create a new clone of the current item, with a new owner assignment /// </summary> /// <param name="owner"> /// The new <see cref="Axis"/> instance that will be the owner of the new Scale /// </param> /// <returns> /// A new <see cref="Scale"/> clone. /// </returns> public abstract Scale Clone(Axis owner);
/// <summary> /// Draw all the <see cref="JapaneseCandleStick"/>'s to the specified <see cref="Graphics"/> /// device as a candlestick at each defined point. /// </summary> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the PaintEventArgs argument to the Paint() method. /// </param> /// <param name="pane"> /// A reference to the <see cref="GraphPane"/> object that is the parent or owner of this object. /// </param> /// <param name="curve"> /// A <see cref="JapaneseCandleStickItem"/> object representing the /// <see cref="JapaneseCandleStick"/>'s to be drawn. /// </param> /// <param name="baseAxis"> /// The <see cref="Axis"/> class instance that defines the base (independent) axis for the <see cref="JapaneseCandleStick"/> /// </param> /// <param name="valueAxis"> /// The <see cref="Axis"/> class instance that defines the value (dependent) axis for the <see cref="JapaneseCandleStick"/> /// </param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and passed down by the parent <see cref="GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust font sizes, etc. according to the actual size of the graph. /// </param> public void Draw(Graphics g, GraphPane pane, JapaneseCandleStickItem curve, Axis baseAxis, Axis valueAxis, float scaleFactor) { // ValueHandler valueHandler = new ValueHandler( pane, false ); float pixBase, pixHigh, pixLow, pixOpen, pixClose; if (curve.Points != null) { // float halfSize = _size * scaleFactor; float halfSize = this.GetBarWidth(pane, baseAxis, scaleFactor); Color tColor = this._color; Color tFallingColor = this._fallingColor; float tPenWidth = this._width; Fill tRisingFill = this._risingFill; Fill tFallingFill = this._fallingFill; Border tRisingBorder = this._risingBorder; Border tFallingBorder = this._fallingBorder; if (curve.IsSelected) { tColor = Selection.Border.Color; tFallingColor = Selection.Border.Color; tPenWidth = Selection.Border.Width; tRisingFill = Selection.Fill; tFallingFill = Selection.Fill; tRisingBorder = Selection.Border; tFallingBorder = Selection.Border; } using (Pen risingPen = new Pen(tColor, tPenWidth)) using (Pen fallingPen = new Pen(tFallingColor, tPenWidth)) { // Loop over each defined point for (int i = 0; i < curve.Points.Count; i++) { PointPair pt = curve.Points[i]; double date = pt.X; double high = pt.Y; double low = pt.Z; double open = PointPairBase.Missing; double close = PointPairBase.Missing; if (pt is StockPt) { open = (pt as StockPt).Open; close = (pt as StockPt).Close; } // Any value set to double max is invalid and should be skipped // This is used for calculated values that are out of range, divide // by zero, etc. // Also, any value <= zero on a log scale is invalid if (!curve.Points[i].IsInvalid3D && (date > 0 || !baseAxis._scale.IsLog) && ((high > 0 && low > 0) || !valueAxis._scale.IsLog)) { pixBase = (int)(baseAxis.Scale.Transform(curve.IsOverrideOrdinal, i, date) + 0.5); // pixBase = baseAxis.Scale.Transform( curve.IsOverrideOrdinal, i, date ); pixHigh = valueAxis.Scale.Transform(curve.IsOverrideOrdinal, i, high); pixLow = valueAxis.Scale.Transform(curve.IsOverrideOrdinal, i, low); if (PointPairBase.IsValueInvalid(open)) { pixOpen = float.MaxValue; } else { pixOpen = valueAxis.Scale.Transform(curve.IsOverrideOrdinal, i, open); } if (PointPairBase.IsValueInvalid(close)) { pixClose = float.MaxValue; } else { pixClose = valueAxis.Scale.Transform(curve.IsOverrideOrdinal, i, close); } if (!curve.IsSelected && this._gradientFill.IsGradientValueType) { using (Pen tPen = this.GetPen(pane, scaleFactor, pt)) this.Draw( g, pane, baseAxis is XAxis || baseAxis is X2Axis, pixBase, pixHigh, pixLow, pixOpen, pixClose, halfSize, scaleFactor, tPen, close > open ? tRisingFill : tFallingFill, close > open ? tRisingBorder : tFallingBorder, pt); } else { this.Draw( g, pane, baseAxis is XAxis || baseAxis is X2Axis, pixBase, pixHigh, pixLow, pixOpen, pixClose, halfSize, scaleFactor, close > open ? risingPen : fallingPen, close > open ? tRisingFill : tFallingFill, close > open ? tRisingBorder : tFallingBorder, pt); } } } } } }
/// <summary> /// Initializes a new instance of the <see cref="LinearAsOrdinalScale"/> class. /// The Copy Constructor /// </summary> /// <param name="rhs"> /// The <see cref="LinearAsOrdinalScale"/> object from which to copy /// </param> /// <param name="owner"> /// The <see cref="Axis"/> object that will own the new instance of <see cref="LinearAsOrdinalScale"/> /// </param> public LinearAsOrdinalScale(Scale rhs, Axis owner) : base(rhs, owner) { }
/// <summary> /// Initializes a new instance of the <see cref="OrdinalScale"/> class. /// Default constructor that defines the owner <see cref="Axis"/> /// (containing object) for this new object. /// </summary> /// <param name="owner"> /// The owner, or containing object, of this instance /// </param> public OrdinalScale(Axis owner) : base(owner) { }
/// <summary> /// Draw all the <see cref="ErrorBar"/>'s to the specified <see cref="Graphics"/> /// device as a an error bar at each defined point. /// </summary> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the PaintEventArgs argument to the Paint() method. /// </param> /// <param name="pane"> /// A reference to the <see cref="GraphPane"/> object that is the parent or owner of this object. /// </param> /// <param name="curve"> /// A <see cref="CurveItem"/> object representing the /// <see cref="Bar"/>'s to be drawn. /// </param> /// <param name="baseAxis"> /// The <see cref="Axis"/> class instance that defines the base (independent) axis for the <see cref="Bar"/> /// </param> /// <param name="valueAxis"> /// The <see cref="Axis"/> class instance that defines the value (dependent) axis for the <see cref="Bar"/> /// </param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and passed down by the parent <see cref="GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust font sizes, etc. according to the actual size of the graph. /// </param> public void Draw(Graphics g, GraphPane pane, ErrorBarItem curve, Axis baseAxis, Axis valueAxis, float scaleFactor) { ValueHandler valueHandler = new ValueHandler(pane, false); float pixBase, pixValue, pixLowValue; double scaleBase, scaleValue, scaleLowValue; if (curve.Points != null && this.IsVisible) { using (Pen pen = !curve.IsSelected ? new Pen(this._color, this._penWidth) : new Pen(Selection.Border.Color, Selection.Border.Width)) { // Loop over each defined point for (int i = 0; i < curve.Points.Count; i++) { valueHandler.GetValues(curve, i, out scaleBase, out scaleLowValue, out scaleValue); // Any value set to double max is invalid and should be skipped // This is used for calculated values that are out of range, divide // by zero, etc. // Also, any value <= zero on a log scale is invalid if (!curve.Points[i].IsInvalid3D && (scaleBase > 0 || !baseAxis._scale.IsLog) && ((scaleValue > 0 && scaleLowValue > 0) || !valueAxis._scale.IsLog)) { pixBase = baseAxis.Scale.Transform(curve.IsOverrideOrdinal, i, scaleBase); pixValue = valueAxis.Scale.Transform(curve.IsOverrideOrdinal, i, scaleValue); pixLowValue = valueAxis.Scale.Transform(curve.IsOverrideOrdinal, i, scaleLowValue); // if ( this.fill.IsGradientValueType ) // brush = fill.MakeBrush( _rect, _points[i] ); this.Draw( g, pane, baseAxis is XAxis || baseAxis is X2Axis, pixBase, pixValue, pixLowValue, scaleFactor, pen, curve.IsSelected, curve.Points[i]); } } } } }
/// <summary> /// Initializes a new instance of the <see cref="OrdinalScale"/> class. /// The Copy Constructor /// </summary> /// <param name="rhs"> /// The <see cref="OrdinalScale"/> object from which to copy /// </param> /// <param name="owner"> /// The <see cref="Axis"/> object that will own the new instance of <see cref="OrdinalScale"/> /// </param> public OrdinalScale(Scale rhs, Axis owner) : base(rhs, owner) { }
/// <summary> /// Initializes a new instance of the <see cref="DateAsOrdinalScale"/> class. /// Default constructor that defines the owner <see cref="Axis"/> /// (containing object) for this new object. /// </summary> /// <param name="owner"> /// The owner, or containing object, of this instance /// </param> public DateAsOrdinalScale(Axis owner) : base(owner) { }
/// <summary> /// The set scroll. /// </summary> /// <param name="scrollBar"> /// The scroll bar. /// </param> /// <param name="axis"> /// The axis. /// </param> /// <param name="scrollMin"> /// The scroll min. /// </param> /// <param name="scrollMax"> /// The scroll max. /// </param> private void SetScroll(ScrollBar scrollBar, Axis axis, double scrollMin, double scrollMax) { if (scrollBar != null && axis != null) { scrollBar.Minimum = 0; scrollBar.Maximum = _ScrollControlSpan - 1; if (scrollMin > axis._scale._min) { scrollMin = axis._scale._min; } if (scrollMax < axis._scale._max) { scrollMax = axis._scale._max; } int val = 0; Scale scale = axis._scale; double minLinearized = scale._minLinearized; double maxLinearized = scale._maxLinearized; scrollMin = scale.Linearize(scrollMin); scrollMax = scale.Linearize(scrollMax); double scrollMin2 = scrollMax - (maxLinearized - minLinearized); /* if ( axis.Scale.IsLog ) scrollMin2 = scrollMax / ( axis._scale._max / axis._scale._min ); else scrollMin2 = scrollMax - ( axis._scale._max - axis._scale._min ); */ if (scrollMin >= scrollMin2) { // scrollBar.Visible = false; scrollBar.Enabled = false; scrollBar.Value = 0; } else { double ratio = (maxLinearized - minLinearized) / (scrollMax - scrollMin); /* if ( axis.Scale.IsLog ) ratio = ( Math.Logger( axis._scale._max ) - Math.Logger( axis._scale._min ) ) / ( Math.Logger( scrollMax ) - Math.Logger( scrollMin ) ); else ratio = ( axis._scale._max - axis._scale._min ) / ( scrollMax - scrollMin ); */ int largeChange = (int)(ratio * _ScrollControlSpan + 0.5); if (largeChange < 1) { largeChange = 1; } scrollBar.LargeChange = largeChange; int smallChange = largeChange / _ScrollSmallRatio; if (smallChange < 1) { smallChange = 1; } scrollBar.SmallChange = smallChange; int span = _ScrollControlSpan - largeChange; val = (int)((minLinearized - scrollMin) / (scrollMin2 - scrollMin) * span + 0.5); /* if ( axis.Scale.IsLog ) val = (int)( ( Math.Logger( axis._scale._min ) - Math.Logger( scrollMin ) ) / ( Math.Logger( scrollMin2 ) - Math.Logger( scrollMin ) ) * span + 0.5 ); else val = (int)( ( axis._scale._min - scrollMin ) / ( scrollMin2 - scrollMin ) * span + 0.5 ); */ if (val < 0) { val = 0; } else if (val > span) { val = span; } // if ( ( axis is XAxis && axis.IsReverse ) || ( ( ! axis is XAxis ) && ! axis.IsReverse ) ) if ((axis is XAxis) == axis.Scale.IsReverse) { val = span - val; } if (val < scrollBar.Minimum) { val = scrollBar.Minimum; } if (val > scrollBar.Maximum) { val = scrollBar.Maximum; } scrollBar.Value = val; scrollBar.Enabled = true; // scrollBar.Visible = true; } } }
/// <summary> /// Make a string label that corresponds to a user scale value. /// </summary> /// <param name="axis"> /// The axis from which to obtain the scale value. This determines if it's a date value, linear, log, etc. /// </param> /// <param name="val"> /// The value to be made into a label /// </param> /// <param name="iPt"> /// The ordinal position of the value /// </param> /// <param name="isOverrideOrdinal"> /// true to override the ordinal settings of the axis, and prefer the actual value instead. /// </param> /// <returns> /// The string label. /// </returns> protected string MakeValueLabel(Axis axis, double val, int iPt, bool isOverrideOrdinal) { if (axis != null) { if (axis.Scale.IsDate || axis.Scale.Type == AxisType.DateAsOrdinal) { return XDate.ToString(val, this._pointDateFormat); } if (axis._scale.IsText && axis._scale._textLabels != null) { int i = iPt; if (isOverrideOrdinal) { i = (int)(val - 0.5); } if (i >= 0 && i < axis._scale._textLabels.Length) { return axis._scale._textLabels[i]; } return (i + 1).ToString(); } if (axis.Scale.IsAnyOrdinal && axis.Scale.Type != AxisType.LinearAsOrdinal && !isOverrideOrdinal) { return iPt.ToString(this._pointValueFormat); } return val.ToString(this._pointValueFormat); } return string.Empty; }
/// <summary> /// Draw the this <see cref="Bar"/> to the specified <see cref="Graphics"/> /// device as a bar at each defined point. This method is normally only called by the <see cref="BarItem.Draw"/> method of the /// <see cref="BarItem"/> object /// </summary> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the PaintEventArgs argument to the Paint() method. /// </param> /// <param name="pane"> /// A reference to the <see cref="GraphPane"/> object that is the parent or owner of this object. /// </param> /// <param name="curve"> /// A <see cref="CurveItem"/> object representing the /// <see cref="Bar"/>'s to be drawn. /// </param> /// <param name="baseAxis"> /// The <see cref="Axis"/> class instance that defines the base (independent) axis for the <see cref="Bar"/> /// </param> /// <param name="valueAxis"> /// The <see cref="Axis"/> class instance that defines the value (dependent) axis for the <see cref="Bar"/> /// </param> /// <param name="barWidth"> /// The width of each bar, in pixels. /// </param> /// <param name="pos"> /// The ordinal position of the this bar series (0=first bar, 1=second bar, etc.) in the cluster of bars. /// </param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and passed down by the parent <see cref="GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust font sizes, etc. according to the actual size of the graph. /// </param> public void DrawBars(Graphics g, GraphPane pane, CurveItem curve, Axis baseAxis, Axis valueAxis, float barWidth, int pos, float scaleFactor) { // For non-cluster bar types, the position is always zero since the bars are on top // of eachother BarType barType = pane._barSettings.Type; if (barType == BarType.Overlay || barType == BarType.Stack || barType == BarType.PercentStack || barType == BarType.SortedOverlay) { pos = 0; } // Loop over each defined point and draw the corresponding bar for (int i = 0; i < curve.Points.Count; i++) { this.DrawSingleBar(g, pane, curve, i, pos, baseAxis, valueAxis, barWidth, scaleFactor); } }
/// <summary> /// Handle a panning operation for the specified <see cref="Axis"/>. /// </summary> /// <param name="axis"> /// The <see cref="Axis"/> to be panned /// </param> /// <param name="startVal"> /// The value where the pan started. The scale range will be shifted by the difference between <see paramref="startVal"/> and /// <see paramref="endVal"/>. /// </param> /// <param name="endVal"> /// The value where the pan ended. The scale range will be shifted by the difference between <see paramref="startVal"/> and /// <see paramref="endVal"/>. /// </param> protected void PanScale(Axis axis, double startVal, double endVal) { if (axis != null) { Scale scale = axis._scale; double delta = scale.Linearize(startVal) - scale.Linearize(endVal); scale._minLinearized += delta; scale._maxLinearized += delta; scale._minAuto = false; scale._maxAuto = false; /* if ( axis.Type == AxisType.Logger ) { axis._scale._min *= startVal / endVal; axis._scale._max *= startVal / endVal; } else { axis._scale._min += startVal - endVal; axis._scale._max += startVal - endVal; } */ } }
/// <summary> /// Protected internal routine that draws the specified single bar (an individual "point") of this series to the specified <see cref="Graphics"/> /// device. /// </summary> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the PaintEventArgs argument to the Paint() method. /// </param> /// <param name="pane"> /// A reference to the <see cref="GraphPane"/> object that is the parent or owner of this object. /// </param> /// <param name="curve"> /// A <see cref="CurveItem"/> object representing the /// <see cref="Bar"/>'s to be drawn. /// </param> /// <param name="index"> /// The zero-based index number for the single bar to be drawn. /// </param> /// <param name="pos"> /// The ordinal position of the this bar series (0=first bar, 1=second bar, etc.) in the cluster of bars. /// </param> /// <param name="baseAxis"> /// The <see cref="Axis"/> class instance that defines the base (independent) axis for the <see cref="Bar"/> /// </param> /// <param name="valueAxis"> /// The <see cref="Axis"/> class instance that defines the value (dependent) axis for the <see cref="Bar"/> /// </param> /// <param name="barWidth"> /// The width of each bar, in pixels. /// </param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and passed down by the parent <see cref="GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust font sizes, etc. according to the actual size of the graph. /// </param> protected virtual void DrawSingleBar( Graphics g, GraphPane pane, CurveItem curve, int index, int pos, Axis baseAxis, Axis valueAxis, float barWidth, float scaleFactor) { // pixBase = pixel value for the bar center on the base axis // pixHiVal = pixel value for the bar top on the value axis // pixLowVal = pixel value for the bar bottom on the value axis float pixBase, pixHiVal, pixLowVal; float clusterWidth = pane.BarSettings.GetClusterWidth(); // float barWidth = curve.GetBarWidth( pane ); float clusterGap = pane._barSettings.MinClusterGap * barWidth; float barGap = barWidth * pane._barSettings.MinBarGap; // curBase = the scale value on the base axis of the current bar // curHiVal = the scale value on the value axis of the current bar // curLowVal = the scale value of the bottom of the bar double curBase, curLowVal, curHiVal; ValueHandler valueHandler = new ValueHandler(pane, false); valueHandler.GetValues(curve, index, out curBase, out curLowVal, out curHiVal); // Any value set to double max is invalid and should be skipped // This is used for calculated values that are out of range, divide // by zero, etc. // Also, any value <= zero on a log scale is invalid if (!curve.Points[index].IsInvalid) { // calculate a pixel value for the top of the bar on value axis pixLowVal = valueAxis.Scale.Transform(curve.IsOverrideOrdinal, index, curLowVal); pixHiVal = valueAxis.Scale.Transform(curve.IsOverrideOrdinal, index, curHiVal); // calculate a pixel value for the center of the bar on the base axis pixBase = baseAxis.Scale.Transform(curve.IsOverrideOrdinal, index, curBase); // Calculate the pixel location for the side of the bar (on the base axis) float pixSide = pixBase - clusterWidth / 2.0F + clusterGap / 2.0F + pos * (barWidth + barGap); // Draw the bar if (pane._barSettings.Base == BarBase.X) { this.Draw(g, pane, pixSide, pixSide + barWidth, pixLowVal, pixHiVal, scaleFactor, true, curve.IsSelected, curve.Points[index]); } else { this.Draw(g, pane, pixLowVal, pixHiVal, pixSide, pixSide + barWidth, scaleFactor, true, curve.IsSelected, curve.Points[index]); } } }
/// <summary> /// Zoom the specified axis by the specified amount, with the center of the zoom at the (optionally) specified point. /// </summary> /// <remarks> /// This method is used for MouseWheel zoom operations /// </remarks> /// <param name="axis"> /// The <see cref="Axis"/> to be zoomed. /// </param> /// <param name="zoomFraction"> /// The zoom fraction, less than 1.0 to zoom in, greater than 1.0 to zoom out. That is, a value of 0.9 will zoom in such that the scale length is 90% of /// what it previously was. /// </param> /// <param name="centerVal"> /// The location for the center of the zoom. This is only used if /// <see paramref="IsZoomOnMouseCenter"/> is true. /// </param> /// <param name="isZoomOnCenter"> /// true if the zoom is to be centered at the /// <see paramref="centerVal"/> screen position, false for the zoom to be centered within the <see cref="Chart.Rect"/>. /// </param> protected void ZoomScale(Axis axis, double zoomFraction, double centerVal, bool isZoomOnCenter) { if (axis != null && zoomFraction > 0.0001 && zoomFraction < 1000.0) { Scale scale = axis._scale; /* if ( axis.Scale.IsLog ) { double ratio = Math.Sqrt( axis._scale._max / axis._scale._min * zoomFraction ); if ( !isZoomOnCenter ) centerVal = Math.Sqrt( axis._scale._max * axis._scale._min ); axis._scale._min = centerVal / ratio; axis._scale._max = centerVal * ratio; } else { */ double minLin = axis._scale._minLinearized; double maxLin = axis._scale._maxLinearized; double range = (maxLin - minLin) * zoomFraction / 2.0; if (!isZoomOnCenter) { centerVal = (maxLin + minLin) / 2.0; } axis._scale._minLinearized = centerVal - range; axis._scale._maxLinearized = centerVal + range; // } axis._scale._minAuto = false; axis._scale._maxAuto = false; } }
/// <summary> /// Initializes a new instance of the <see cref="DateScale"/> class. /// Default constructor that defines the owner <see cref="Axis"/> /// (containing object) for this new object. /// </summary> /// <param name="owner"> /// The owner, or containing object, of this instance /// </param> public DateScale(Axis owner) : base(owner) { }
/* /// <summary> /// Protected internal routine that draws the specified single bar (an individual "point") /// of this series to the specified <see cref="Graphics"/> device. /// </summary> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the /// PaintEventArgs argument to the Paint() method. /// </param> /// <param name="pane"> /// A reference to the <see cref="GraphPane"/> object that is the parent or /// owner of this object. /// </param> /// <param name="curve">A <see cref="CurveItem"/> object representing the /// <see cref="Bar"/>'s to be drawn.</param> /// <param name="index"> /// The zero-based index number for the single bar to be drawn. /// </param> /// <param name="pos"> /// The ordinal position of the this bar series (0=first bar, 1=second bar, etc.) /// in the cluster of bars. /// </param> /// <param name="baseAxis">The <see cref="Axis"/> class instance that defines the base (independent) /// axis for the <see cref="Bar"/></param> /// <param name="valueAxis">The <see cref="Axis"/> class instance that defines the value (dependent) /// axis for the <see cref="Bar"/></param> /// <param name="barWidth"> /// The width of each bar, in pixels. /// </param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and /// passed down by the parent <see cref="GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust /// font sizes, etc. according to the actual size of the graph. /// </param> override protected void DrawSingleBar( Graphics g, GraphPane pane, CurveItem curve, int index, int pos, Axis baseAxis, Axis valueAxis, float barWidth, float scaleFactor ) { //float scaledSize = GetBarWidth( pane, baseAxis, scaleFactor ); // pixBase = pixel value for the bar center on the base axis // pixValue = pixel value for the bar top on the value axis // pixLow = pixel value for the bar bottom on the value axis float pixBase, pixHiVal, pixLowVal; // curBase = the scale value on the base axis of the current bar // curValue = the scale value on the value axis of the current bar double curBase, curLowVal, curHiVal; ValueHandler valueHandler = new ValueHandler( pane, false ); valueHandler.GetValues( curve, index, out curBase, out curLowVal, out curHiVal ); barWidth = GetBarWidth( pane, baseAxis, scaleFactor ); // curLow = the scale value on the value axis for the bottom of the current bar // Get a "low" value for the bottom of the bar and verify validity if ( curLowVal == PointPair.Missing || System.Double.IsNaN( curLowVal ) || System.Double.IsInfinity( curLowVal ) ) curLowVal = 0; // Any value set to double max is invalid and should be skipped // This is used for calculated values that are out of range, divide // by zero, etc. // Also, any value <= zero on a log scale is invalid if ( !curve.Points[index].IsInvalid ) { // calculate a pixel value for the top of the bar on value axis pixHiVal = valueAxis.Scale.Transform( curve.IsOverrideOrdinal, index, curHiVal ); // calculate a pixel value for the center of the bar on the base axis pixBase = baseAxis.Scale.Transform( curve.IsOverrideOrdinal, index, curBase ); pixLowVal = valueAxis.Scale.Transform( curve.IsOverrideOrdinal, index, curLowVal ); // Calculate the pixel location for the side of the bar (on the base axis) float pixSide = pixBase - barWidth / 2.0F; // Calculate the pixel location for the side of the bar (on the base axis) float pixSide = pixBase - clusterWidth / 2.0F + clusterGap / 2.0F + pos * ( barWidth + barGap ); // Draw the bar if ( baseAxis is XAxis || baseAxis is X2Axis ) this.Draw( g, pane, pixSide, pixSide + barWidth, pixLowVal, pixHiVal, scaleFactor, true, curve.IsSelected, curve.Points[index] ); else this.Draw( g, pane, pixLowVal, pixHiVal, pixSide, pixSide + barWidth, scaleFactor, true, curve.IsSelected, curve.Points[index] ); } } */ /// <summary> /// Returns the width of the bar, in pixels, based on the settings for /// <see cref="Size"/> and <see cref="IsAutoSize"/>. /// </summary> /// <param name="pane"> /// The parent <see cref="GraphPane"/> object. /// </param> /// <param name="baseAxis"> /// The <see cref="Axis"/> object that represents the bar base (independent axis). /// </param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and passed down by the parent <see cref="GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust font sizes, etc. according to the actual size of the graph. /// </param> /// <returns> /// The width of each bar, in pixel units /// </returns> public float GetBarWidth(GraphPane pane, Axis baseAxis, float scaleFactor) { float width; if (this._isAutoSize) { width = baseAxis._scale.GetClusterWidth(this._userScaleSize) / (1.0F + pane._barSettings.MinClusterGap); } else { width = this._size * scaleFactor; } // use integral size return (int)(width + 0.5f); }
/// <summary> /// Initializes a new instance of the <see cref="Axis"/> class. /// The Copy Constructor. /// </summary> /// <param name="rhs"> /// The Axis object from which to copy /// </param> public Axis(Axis rhs) { this._scale = rhs._scale.Clone(this); this._cross = rhs._cross; this._crossAuto = rhs._crossAuto; this._majorTic = rhs.MajorTic.Clone(); this._minorTic = rhs.MinorTic.Clone(); this._majorGrid = rhs._majorGrid.Clone(); this._minorGrid = rhs._minorGrid.Clone(); this._isVisible = rhs.IsVisible; this._isAxisSegmentVisible = rhs._isAxisSegmentVisible; this._title = rhs.Title.Clone(); this._axisGap = rhs._axisGap; this._minSpace = rhs.MinSpace; this._color = rhs.Color; }
/// <summary> /// Create a new clone of the current item, with a new owner assignment /// </summary> /// <param name="owner"> /// The new <see cref="Axis"/> instance that will be the owner of the new Scale /// </param> /// <returns> /// A new <see cref="Scale"/> clone. /// </returns> public override Scale Clone(Axis owner) { return new OrdinalScale(this, owner); }
/// <summary> /// The set space. /// </summary> /// <param name="axis"> /// The axis. /// </param> /// <param name="clientSize"> /// The client size. /// </param> /// <param name="spaceNorm"> /// The space norm. /// </param> /// <param name="spaceAlt"> /// The space alt. /// </param> private void SetSpace(Axis axis, float clientSize, ref float spaceNorm, ref float spaceAlt) { // spaceNorm = 0; // spaceAlt = 0; float crossFrac = axis.CalcCrossFraction(this); float crossPix = crossFrac * (1 + crossFrac) * (1 + crossFrac * crossFrac) * clientSize; if (!axis.IsPrimary(this) && axis.IsCrossShifted(this)) { axis._tmpSpace = 0; } if (axis._tmpSpace < crossPix) { axis._tmpSpace = 0; } else if (crossPix > 0) { axis._tmpSpace -= crossPix; } if (axis._scale._isLabelsInside && (axis.IsPrimary(this) || (crossFrac != 0.0 && crossFrac != 1.0))) { spaceAlt = axis._tmpSpace; } else { spaceNorm = axis._tmpSpace; } }
/// <summary> /// Initializes a new instance of the <see cref="LinearScale"/> class. /// The Copy Constructor /// </summary> /// <param name="rhs"> /// The <see cref="LinearScale"/> object from which to copy /// </param> /// <param name="owner"> /// The <see cref="Axis"/> object that will own the new instance of <see cref="LinearScale"/> /// </param> public LinearScale(Scale rhs, Axis owner) : base(rhs, owner) { }