public AxisScaleController(XYPlotLayer layer, int axisnumber)
{
m_Layer = layer;
m_axisNumber = axisnumber;
m_Axis = m_Layer.LinkedScales.Scale(axisnumber);
_tempAxis = (Scale)m_Axis.Clone();
SetElements();
}
public LinkedScale(Scale scaleToWrap, int scaleNumberLinkedTo)
{
_linkParameters = new LinkedScaleParameters() { ParentObject = this };
WrappedScale = scaleToWrap;
_linkedScaleIndex = scaleNumberLinkedTo;
}
public LinkedScale(Scale scaleToWrap)
{
_linkParameters = new LinkedScaleParameters() { ParentObject = this };
WrappedScale = scaleToWrap;
}
public TransformedScale(Scale scale, double offset)
{
_originalScale = scale;
_offset = offset;
}
/// <summary>
/// Checks if the scale in the argument is dependend on this Scale. This would mean a circular dependency, which should be avoided.
/// </summary>
/// <param name="scaleThatWouldBecomeALinkedScale">Scale that is a linked scale or that would become a linked scale.</param>
/// <param name="scaleToTest">The scale to check.</param>
/// <returns>True if the provided scale or one of its linked scales is dependend on this scale.</returns>
public static bool WouldScaleBeDependentOnMe(Scale scaleThatWouldBecomeALinkedScale, Scale scaleToTest)
{
if (object.ReferenceEquals(scaleThatWouldBecomeALinkedScale, scaleToTest))
{
return(true); // Scale are identical, thus they are really dependent on each other
}
var linkedScale = scaleToTest as LinkedScale;
while (null != linkedScale)
{
if (object.ReferenceEquals(scaleThatWouldBecomeALinkedScale, linkedScale))
{
return(true); // this means a direct circular dependency (we are at the original scale), so return true
}
if (object.ReferenceEquals(scaleThatWouldBecomeALinkedScale, linkedScale.ScaleLinkedTo))
{
return(true); // That would mean a circular dependency also, thus also return true;
}
linkedScale = linkedScale.ScaleLinkedTo as LinkedScale;
}
return(false); // no dependency detected
}
public LayerSegment(IPlotArea underlyingArea, Scale scale, Logical3D org, Logical3D end, int scaleNumber)
{
_underlyingArea = underlyingArea;
_org = org;
_end = end;
_scaleNumber = scaleNumber;
for (int i = 0; i < _underlyingArea.Scales.Count; ++i)
{
if (i == _scaleNumber)
_scaleCollection[i] = scale;
else
_scaleCollection[i] = (Scale)underlyingArea.Scales[i].Clone();
}
}
public void SetScale(int i, Scale ax)
{
_linkedScales[i].Scale = ax;
}
/// <summary>
/// Checks if the scale in the argument is dependend on this Scale. This would mean a circular dependency, which should be avoided.
/// </summary>
/// <param name="scaleThatWouldBecomeALinkedScale">Scale that is a linked scale or that would become a linked scale.</param>
/// <param name="scaleToTest">The scale to check.</param>
/// <returns>True if the provided scale or one of its linked scales is dependend on this scale.</returns>
public static bool WouldScaleBeDependentOnMe(Scale scaleThatWouldBecomeALinkedScale, Scale scaleToTest)
{
if (object.ReferenceEquals(scaleThatWouldBecomeALinkedScale, scaleToTest))
return true; // Scale are identical, thus they are really dependent on each other
var linkedScale = scaleToTest as LinkedScale;
while (null != linkedScale)
{
if (object.ReferenceEquals(scaleThatWouldBecomeALinkedScale, linkedScale))
return true; // this means a direct circular dependency (we are at the original scale), so return true
if (object.ReferenceEquals(scaleThatWouldBecomeALinkedScale, linkedScale.ScaleLinkedTo))
return true; // That would mean a circular dependency also, thus also return true;
linkedScale = linkedScale.ScaleLinkedTo as LinkedScale;
}
return false; // no dependency detected
}
/// <summary>
/// Paints the axis style labels.
/// </summary>
/// <param name="g">Graphics environment.</param>
/// <param name="coordSyst">The coordinate system. Used to get the path along the axis.</param>
/// <param name="scale">Scale.</param>
/// <param name="tickSpacing">If not <c>null</c>, this parameter provides a custom tick spacing that is used instead of the default tick spacing of the scale.</param>
/// <param name="styleInfo">Information about begin of axis, end of axis.</param>
/// <param name="outerDistance">Distance between axis and labels.</param>
/// <param name="useMinorTicks">If true, minor ticks are shown.</param>
public virtual void Paint(IGraphicsContext3D g, G3DCoordinateSystem coordSyst, Scale scale, TickSpacing tickSpacing, CSAxisInformation styleInfo, double outerDistance, bool useMinorTicks)
{
_cachedAxisStyleInfo = styleInfo;
CSLineID styleID = styleInfo.Identifier;
Scale raxis = scale;
TickSpacing ticking = tickSpacing;
var math = Matrix4x3.Identity;
Logical3D r0 = styleID.GetLogicalPoint(styleInfo.LogicalValueAxisOrg);
Logical3D r1 = styleID.GetLogicalPoint(styleInfo.LogicalValueAxisEnd);
VectorD3D outVector;
Logical3D outer;
double[] relpositions;
AltaxoVariant[] ticks;
if (useMinorTicks)
{
relpositions = ticking.GetMinorTicksNormal(raxis);
ticks = ticking.GetMinorTicksAsVariant();
}
else
{
relpositions = ticking.GetMajorTicksNormal(raxis);
ticks = ticking.GetMajorTicksAsVariant();
}
if (!_suppressedLabels.IsEmpty)
{
List<AltaxoVariant> filteredTicks = new List<AltaxoVariant>();
List<double> filteredRelPositions = new List<double>();
for (int i = 0; i < ticks.Length; i++)
{
if (_suppressedLabels.ByValues.Contains(ticks[i]))
continue;
if (_suppressedLabels.ByNumbers.Contains(i))
continue;
if (_suppressedLabels.ByNumbers.Contains(i - ticks.Length))
continue;
filteredTicks.Add(ticks[i]);
filteredRelPositions.Add(relpositions[i]);
}
ticks = filteredTicks.ToArray();
relpositions = filteredRelPositions.ToArray();
}
IMeasuredLabelItem[] labels = _labelFormatting.GetMeasuredItems(g, _font, ticks);
double emSize = _font.Size;
CSAxisSide labelSide = null != _labelSide ? _labelSide.Value : styleInfo.PreferredLabelSide;
var labelOutlines = new RectangularObjectOutline[ticks.Length];
for (int i = 0; i < ticks.Length; i++)
{
double r = relpositions[i];
if (!Altaxo.Calc.RMath.IsInIntervalCC(r, -1000, 1000))
continue;
outer = coordSyst.GetLogicalDirection(styleID.ParallelAxisNumber, labelSide);
PointD3D tickorg = coordSyst.GetPositionAndNormalizedDirection(r0, r1, r, outer, out outVector);
PointD3D tickend = tickorg + outVector * outerDistance;
var msize = labels[i].Size;
var morg = tickend;
if (_automaticRotationShift)
{
// if this option is choosen, we have to find a shift value that shifts the center of the text outwards so that the bounding box of the text will not cross the plane that is
// defined by the tickend point and the normal vector outVector
// Assume that the text is now centered x, y, and z around the point tickend (but here we use origin instead tickend)
math = Matrix4x3.NewRotation(_rotationX, _rotationY, _rotationZ);
// we have to find all points with negative distance to the plane spanned by tickend and the vector outVector (but again instead of tickend we use origin)
var msizePad = msize + new VectorD3D(
(_font.Size * 1) / 3, // whereas above and below text no padding is neccessary, it is optically nicer to have left and right padding of the string by 1/6 of font size.
0,
(_font.Size * 1) / 3 // same padding applies to z
);
var crect = new RectangleD3D((PointD3D)(-0.5 * msizePad), msizePad); // our text centered around origin
double shift = 0;
foreach (PointD3D p in crect.Vertices)
{
PointD3D ps = math.Transform(p);
double distance = Math3D.GetDistancePointToPlane(ps, PointD3D.Empty, outVector);
if (-distance > shift)
shift = -distance; // only negative distances will count here
}
morg += outVector * shift;
}
else
{
morg = morg.WithXPlus(outVector.X * _font.Size / 3);
}
var mrect = new RectangleD3D(morg, msize);
if (_automaticRotationShift)
mrect = AdjustRectangle(mrect, Alignment.Center, Alignment.Center, Alignment.Center);
else
mrect = AdjustRectangle(mrect, _alignmentX, _alignmentY, _alignmentZ);
math = Matrix4x3.Identity;
math.TranslatePrepend(morg.X, morg.Y, morg.Z);
if (this._rotationZ != 0)
math.RotationZDegreePrepend(this._rotationZ);
if (this._rotationY != 0)
math.RotationYDegreePrepend(this._rotationY);
if (this._rotationX != 0)
math.RotationXDegreePrepend(this._rotationX);
math.TranslatePrepend((mrect.X - morg.X + emSize * _offsetX), (mrect.Y - morg.Y + emSize * _offsetY), (mrect.Z - morg.Z + emSize * _offsetZ));
var gs = g.SaveGraphicsState();
g.PrependTransform(math);
if (this._backgroundStyle != null)
{
var itemRectangle = new RectangleD3D(PointD3D.Empty, msize);
_backgroundStyle.Measure(itemRectangle);
_backgroundStyle.Draw(g, itemRectangle);
}
labels[i].Draw(g, _brush, PointD3D.Empty);
labelOutlines[i] = new RectangularObjectOutline(new RectangleD3D(PointD3D.Empty, msize), math);
g.RestoreGraphicsState(gs); // Restore the graphics state
}
_cachedLabelOutlines = labelOutlines;
}
public void EhView_AxisTypeChanged(string text)
{
m_AxisType = text;
try
{
System.Type axistype = (System.Type)Scale.AvailableAxes[m_AxisType];
if(null!=axistype)
{
if(axistype!=_tempAxis.GetType())
{
// replace the current axis by a new axis of the type axistype
Scale _oldAxis = _tempAxis;
_tempAxis = (Scale)System.Activator.CreateInstance(axistype);
// Try to set the same org and end as the axis before
// this will fail for instance if we switch from linear to logarithmic with negative bounds
try
{
_tempAxis.ProcessDataBounds(_oldAxis.OrgAsVariant,true,_oldAxis.EndAsVariant,true);
}
catch(Exception)
{
}
SetScaleController(true);
// now we have also to replace the controller and the control for the axis boundaries
SetBoundaryController(true);
}
}
}
catch(Exception )
{
}
}
public DensityLegendArea(PointD2D size, bool isXYInterchanged, bool isXReversed, Scale scale, TickSpacing tickSpacing)
{
_size = size;
_scales = new ScaleCollection() { ParentObject = this };
_scales[0] = scale; scale.TickSpacing = tickSpacing;
_scales[1] = new LinearScale() { TickSpacing = new NoTickSpacing() };
_coordinateSystem = new Altaxo.Graph.Gdi.CS.G2DCartesicCoordinateSystem() { ParentObject = this };
_coordinateSystem.IsXYInterchanged = isXYInterchanged;
_coordinateSystem.IsXReverse = isXReversed;
_coordinateSystem.UpdateAreaSize(_size);
}
public override bool CopyFrom(object obj)
{
if (object.ReferenceEquals(this, obj))
return true;
var from = obj as ScaleSegment;
if (null == from)
return false;
using (var suspendToken = SuspendGetToken())
{
this._relOrg = from._relOrg;
this._relEnd = from._relEnd;
this._underlyingScale = from._underlyingScale;
this._segmentScaling = from._segmentScaling;
EhSelfChanged(EventArgs.Empty);
suspendToken.Resume();
}
return true;
}
public ScaleSegment(Scale underlyingScale, double relOrg, double relEnd, ScaleSegmentType scaling)
{
if (null == underlyingScale)
throw new ArgumentNullException("underlyingScale");
_underlyingScale = underlyingScale;
_relOrg = relOrg;
_relEnd = relEnd;
_segmentScaling = scaling;
}
protected override System.Collections.Generic.IEnumerable<Main.DocumentNodeAndName> GetDocumentNodeChildrenWithName()
{
if (null != _scaleWrapped)
yield return new Main.DocumentNodeAndName(_scaleWrapped, () => _scaleWrapped = null, "ScaleWrapped");
if (null != _linkParameters)
yield return new Main.DocumentNodeAndName(_linkParameters, () => _linkParameters = null, "LinkParameters");
if (null != _scaleLinkedToProxy)
yield return new Main.DocumentNodeAndName(_scaleLinkedToProxy, () => _scaleLinkedToProxy = null, "ScaleLinkedTo");
}
public AxisScaleController(XYPlotLayer layer, Scale ax)
{
m_Layer = layer;
m_axisNumber = layer.LinkedScales.IndexOf(ax);
if (m_axisNumber < 0)
throw new ArgumentException("Provided axis is not member of the layer");
m_Axis = ax;
_tempAxis = (Scale)m_Axis.Clone();
SetElements();
}
/// <summary>
/// Checks if the scale in the argument is dependend on this Scale. This would mean a circular dependency, which should be avoided.
/// </summary>
/// <param name="scaleToTest">The scale to check.</param>
/// <returns>True if the provided scale or one of its linked scales is dependend on this scale.</returns>
public bool IsScaleDependentOnMe(Scale scaleToTest)
{
return WouldScaleBeDependentOnMe(this, scaleToTest);
}
/// <summary>
/// Measures if the linked axis has changed.
/// </summary>
/// <param name="linkedAxis">The axis that is the master axis (our axis is linked to this axis).</param>
public void EhLinkedLayerAxesChanged(Scale linkedAxis)
{
if (_isLinked)
{
// we must disable our own interrogator because otherwise we can not change the axis
_scale.IsLinked = false;
_scale.ProcessDataBounds(
LinkOrgA + LinkOrgB * linkedAxis.OrgAsVariant, true,
LinkEndA + LinkEndB * linkedAxis.EndAsVariant, true);
_scale.IsLinked = true; // restore the linked state of the axis
this.OnLinkPropertiesChanged(); // indicate that the axes boundaries have changed
}
}
/// <summary>
/// Paints the axis style labels.
/// </summary>
/// <param name="g">Graphics environment.</param>
/// <param name="coordSyst">The coordinate system. Used to get the path along the axis.</param>
/// <param name="scale">Scale.</param>
/// <param name="tickSpacing">If not <c>null</c>, this parameter provides a custom tick spacing that is used instead of the default tick spacing of the scale.</param>
/// <param name="styleInfo">Information about begin of axis, end of axis.</param>
/// <param name="outerDistance">Distance between axis and labels.</param>
/// <param name="useMinorTicks">If true, minor ticks are shown.</param>
public virtual void Paint(Graphics g, G2DCoordinateSystem coordSyst, Scale scale, TickSpacing tickSpacing, CSAxisInformation styleInfo, double outerDistance, bool useMinorTicks)
{
_cachedAxisStyleInfo = styleInfo;
CSLineID styleID = styleInfo.Identifier;
Scale raxis = scale;
TickSpacing ticking = tickSpacing;
_enclosingPath.Reset();
_enclosingPath.FillMode = FillMode.Winding; // with Winding also overlapping rectangles are selected
GraphicsPath helperPath = new GraphicsPath();
Matrix math = new Matrix();
Logical3D r0 = styleID.GetLogicalPoint(styleInfo.LogicalValueAxisOrg);
Logical3D r1 = styleID.GetLogicalPoint(styleInfo.LogicalValueAxisEnd);
PointD2D outVector;
Logical3D outer;
var dist_x = outerDistance; // Distance from axis tick point to label
var dist_y = outerDistance; // y distance from axis tick point to label
// dist_x += this._font.SizeInPoints/3; // add some space to the horizontal direction in order to separate the chars a little from the ticks
// next statement is necessary to have a consistent string length both
// on 0 degree rotated text and rotated text
// without this statement, the text is fitted to the pixel grid, which
// leads to "steps" during scaling
g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
double[] relpositions;
AltaxoVariant[] ticks;
if (useMinorTicks)
{
relpositions = ticking.GetMinorTicksNormal(raxis);
ticks = ticking.GetMinorTicksAsVariant();
}
else
{
relpositions = ticking.GetMajorTicksNormal(raxis);
ticks = ticking.GetMajorTicksAsVariant();
}
if (!_suppressedLabels.IsEmpty)
{
List<AltaxoVariant> filteredTicks = new List<AltaxoVariant>();
List<double> filteredRelPositions = new List<double>();
for (int i = 0; i < ticks.Length; i++)
{
if (_suppressedLabels.ByValues.Contains(ticks[i]))
continue;
if (_suppressedLabels.ByNumbers.Contains(i))
continue;
if (_suppressedLabels.ByNumbers.Contains(i - ticks.Length))
continue;
filteredTicks.Add(ticks[i]);
filteredRelPositions.Add(relpositions[i]);
}
ticks = filteredTicks.ToArray();
relpositions = filteredRelPositions.ToArray();
}
IMeasuredLabelItem[] labels = _labelFormatting.GetMeasuredItems(g, _font, _stringFormat, ticks);
double emSize = _font.Size;
CSAxisSide labelSide = null != _labelSide ? _labelSide.Value : styleInfo.PreferredLabelSide;
for (int i = 0; i < ticks.Length; i++)
{
double r = relpositions[i];
if (!Altaxo.Calc.RMath.IsInIntervalCC(r, -1000, 1000))
continue;
outer = coordSyst.GetLogicalDirection(styleID.ParallelAxisNumber, labelSide);
PointD2D tickorg = coordSyst.GetNormalizedDirection(r0, r1, r, outer, out outVector);
PointD2D tickend = tickorg + outVector * outerDistance;
PointD2D msize = labels[i].Size;
PointD2D morg = tickend;
if (_automaticRotationShift)
{
double alpha = _rotation * Math.PI / 180 - Math.Atan2(outVector.Y, outVector.X);
double shift = msize.Y * 0.5 * Math.Abs(Math.Sin(alpha)) + (msize.X + _font.Size / 2) * 0.5 * Math.Abs(Math.Cos(alpha));
morg = morg + outVector * shift;
}
else
{
morg = morg.WithXPlus(outVector.X * _font.Size / 3);
}
RectangleD2D mrect = new RectangleD2D(morg, msize);
if (_automaticRotationShift)
AdjustRectangle(ref mrect, StringAlignment.Center, StringAlignment.Center);
else
AdjustRectangle(ref mrect, _horizontalAlignment, _verticalAlignment);
math.Reset();
math.Translate((float)morg.X, (float)morg.Y);
if (this._rotation != 0)
{
math.Rotate((float)-this._rotation);
}
math.Translate((float)(mrect.X - morg.X + emSize * _xOffset), (float)(mrect.Y - morg.Y + emSize * _yOffset));
System.Drawing.Drawing2D.GraphicsState gs = g.Save();
g.MultiplyTransform(math);
if (this._backgroundStyle != null)
_backgroundStyle.Draw(g, new RectangleD2D(PointD2D.Empty, msize));
_brush.SetEnvironment(new RectangleD2D(PointD2D.Empty, msize), BrushX.GetEffectiveMaximumResolution(g, 1));
labels[i].Draw(g, _brush, new PointF(0, 0));
g.Restore(gs); // Restore the graphics state
helperPath.Reset();
helperPath.AddRectangle(new RectangleF(PointF.Empty, (SizeF)msize));
helperPath.Transform(math);
_enclosingPath.AddPath(helperPath, true);
}
}
/// <summary>
/// Checks if the scale in the argument is dependend on this Scale. This would mean a circular dependency, which should be avoided.
/// </summary>
/// <param name="scaleToTest">The scale to check.</param>
/// <returns>True if the provided scale or one of its linked scales is dependend on this scale.</returns>
public bool IsScaleDependentOnMe(Scale scaleToTest)
{
return(WouldScaleBeDependentOnMe(this, scaleToTest));
}
public int IndexOf(Scale ax)
{
for (int i = 0; i < _linkedScales.Length; i++)
{
if (_linkedScales[i].Scale == ax)
return i;
}
return -1;
}
public void SetScale(int i, Scale ax)
{
_linkedScales[i].Scale = ax;
}
