public override void FinalProcessScaleBoundaries(Altaxo.Data.AltaxoVariant org, Altaxo.Data.AltaxoVariant end, Scale scale)
{
_minorTicks.Clear();
_majorTicks.Clear();
_majorTextTicks.Clear();
// make major ticks at integral numbers and minor ticks at halfway
double dorg = org;
double dend = end;
if (!(dorg < dend))
{
return;
}
double span = Math.Abs(dend - dorg);
if (double.IsInfinity(span))
{
return;
}
var textBounds = scale.DataBoundsObject as Boundaries.TextBoundaries;
double majorSpan = 1;
if (span > 100)
{
majorSpan = Math.Ceiling(span / 100);
}
double minorSpan = majorSpan / 2;
double firstmajor = Math.Floor(dorg / majorSpan) - 1; // -1 for safety and for minor
double lastmajor = Math.Ceiling(dend / majorSpan) + 1; // +1 for safety
for (double maj = firstmajor; maj <= lastmajor; maj += 1)
{
double majortick = maj * majorSpan;
double minortick = maj * majorSpan - minorSpan;
if (majortick.IsInIntervalCC(dorg, dend))
{
_majorTicks.Add(majortick);
int item = (int)(majortick - 1);
if (textBounds != null && item >= 0 && item < textBounds.NumberOfItems)
{
_majorTextTicks.Add(textBounds.GetItem(item));
}
else
{
_majorTextTicks.Add(majortick);
}
}
if (minortick.IsInIntervalCC(dorg, dend))
{
_minorTicks.Add(minortick);
}
}
}
public virtual void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
{
AltaxoVariant s = (AltaxoVariant)obj;
info.AddEnum("Content", s.m_Content);
switch (s.m_Content)
{
case Content.VNull:
break;
case Content.VDouble:
info.AddValue("Value", s.m_Double);
break;
case Content.VDateTime:
info.AddValue("Value", (DateTime)s.m_Object);
break;
case Content.VString:
info.AddValue("Value", (string)s.m_Object);
break;
default:
info.AddValue("Value", s.m_Object);
break;
}
}
protected virtual AltaxoVariant SDeserialize(object o, Altaxo.Serialization.Xml.IXmlDeserializationInfo info, object parent)
{
AltaxoVariant s = (o == null ? new AltaxoVariant() : (AltaxoVariant)o);
var c = (Content)info.GetEnum("Content", typeof(Content));
s._typeOfContent = c;
switch (c)
{
case Content.VNull:
break;
case Content.VDouble:
s._double = info.GetDouble("Value");
break;
case Content.VDateTime:
s._object = info.GetDateTime("Value");
break;
case Content.VString:
s._object = info.GetString("Value");
break;
default:
s._object = info.GetValue("Value", s);
break;
}
return(s);
}
public override void ProcessDataBounds(Altaxo.Data.AltaxoVariant org, bool orgfixed, Altaxo.Data.AltaxoVariant end, bool endfixed)
{
double dorg = org.ToDouble();
double dend = end.ToDouble();
if (!orgfixed)
{
dorg = Math.Ceiling(dorg) - 0.5;
}
if (!endfixed)
{
dend = Math.Floor(dend) + 0.5;
}
bool changed = false;
changed |= _cachedAxisOrg != dorg;
_cachedAxisOrg = dorg;
changed |= _cachedAxisEnd != dend;
_cachedAxisEnd = dend;
changed |= _cachedAxisSpan != (dend - dorg);
_cachedAxisSpan = dend - dorg;
changed |= _cachedOneByAxisSpan != (1 / _cachedAxisSpan);
_cachedOneByAxisSpan = 1 / _cachedAxisSpan;
if (changed)
{
OnChanged();
}
}
/// <inheritdoc/>
public virtual bool CopyFrom(object obj, bool copyWithDataReferences)
{
if (object.ReferenceEquals(this, obj))
{
return(true);
}
var from = obj as BarGraphPlotStyle;
if (null != from)
{
_relInnerGapX = from._relInnerGapX;
_relOuterGapX = from._relOuterGapX;
_xSizeLogical = from._xSizeLogical;
_xOffsetLogical = from._xOffsetLogical;
_independentFillColor = from._independentFillColor;
ChildCloneToMember(ref _fillBrush, from._fillBrush);
_independentFrameColor = from._independentFrameColor;
ChildCloneToMember(ref _framePen, from._framePen);
_startAtPreviousItem = from._startAtPreviousItem;
_previousItemYGap = from._previousItemYGap;
_usePhysicalBaseValue = from._usePhysicalBaseValue;
_baseValue = from._baseValue;
EhSelfChanged();
return(true);
}
return(false);
}
void DisplayData(int layerNumber, Altaxo.Data.AltaxoVariant x, Altaxo.Data.AltaxoVariant y)
{
Current.DataDisplay.WriteOneLine(string.Format(
"Layer({0}) X={1}, Y={2}",
layerNumber,
x,
y));
}
public void Swap(int i, int j)
{
foreach (DataColumn col in _colsToSwap)
{
_var = col[i];
col[i] = col[j];
col[j] = _var;
}
}
public void MergeYBoundsInto(IPlotArea layer, IPhysicalBoundaries pb, PlotItemCollection coll)
{
Dictionary<G2DPlotItem, Processed2DPlotData> plotDataList;
IPhysicalBoundaries pbclone = (IPhysicalBoundaries)pb.Clone(); // before we can use CanUseStyle, we have to give physical y boundaries template
CoordinateTransformingStyleBase.MergeYBoundsInto(pbclone, coll);
if (!CanUseStyle(layer, coll, out plotDataList))
{
pb.Add(pbclone);
return;
}
// we put zero into the y-Boundaries, since the addition starts with that value
pb.Add(new AltaxoVariant(0.0));
AltaxoVariant[] ySumArray = null;
int idx = -1;
foreach (IGPlotItem pi in coll)
{
if (pi is G2DPlotItem)
{
idx++;
G2DPlotItem gpi = (G2DPlotItem)pi;
Processed2DPlotData pdata = plotDataList[gpi];
// Note: we can not use AddUp function here, since
// when we have positive/negative items, the intermediate bounds
// might be wider than the bounds of the end result
if (ySumArray == null)
{
ySumArray = new AltaxoVariant[pdata.RangeList.PlotPointCount];
int j = -1;
foreach (int originalIndex in pdata.RangeList.OriginalRowIndices())
{
j++;
ySumArray[j] = pdata.GetYPhysical(originalIndex);
pb.Add(ySumArray[j]);
}
}
else // this is not the first item
{
int j = -1;
foreach (int originalIndex in pdata.RangeList.OriginalRowIndices())
{
j++;
ySumArray[j] += pdata.GetYPhysical(originalIndex);
pb.Add(ySumArray[j]);
}
}
}
}
}
public override Altaxo.Data.AltaxoVariant[] GetMinorTicksAsVariant()
{
AltaxoVariant[] result = new AltaxoVariant[_dataBounds.NumberOfItems + 1];
for (int i = 0; i < result.Length; i++)
{
result[i] = new Altaxo.Data.AltaxoVariant(i + 0.5);
}
return(result);
}
public override VectorD3D MeasureItem(IGraphicsContext3D g, FontX3D font, Altaxo.Data.AltaxoVariant mtick, PointD3D morg)
{
SplitInFirstPartAndExponent(mtick, out var firstpart, out var mant, out var middelpart, out var exponent);
var size1 = g.MeasureString(_prefix + firstpart + middelpart, font, PointD3D.Empty);
var size2 = g.MeasureString(exponent, font, PointD3D.Empty);
var size3 = g.MeasureString(_suffix, font, PointD3D.Empty);
return(new VectorD3D(size1.X + size2.X + size3.X, size1.Y, font.Depth));
}
// indexers
public override void SetValueAt(int i, AltaxoVariant val)
{
try
{
this[i] = val.ToDouble();
}
catch (Exception ex)
{
throw new ApplicationException(string.Format("Error: Try to set {0}[{1}] with the string {2}, exception: {3}", this.TypeAndName, i, val.ToString(), ex.Message));
}
}
// indexers
public override void SetValueAt(int i, AltaxoVariant val)
{
try
{
this[i] = val.ToDateTime();
}
catch (Exception ex)
{
throw new ApplicationException(string.Format("Error: Try to set {0}[{1}] with the string {2}, exception: {3}", TypeAndName, i, val.ToString(), ex.Message));
}
}
public override Altaxo.Data.AltaxoVariant[] GetMajorTicksAsVariant()
{
var result = new Altaxo.Data.AltaxoVariant[_dataBounds.NumberOfItems];
for (int i = 0; i < result.Length; i++)
{
result[i] = new AltaxoVariant(_dataBounds.GetItem(i));
}
return(result);
}
public override bool vop_Subtraction_Rev(AltaxoVariant c2, out DataColumn c3)
{
if (c2.IsType(AltaxoVariant.Content.VDateTime))
{
var c22 = (DateTime)c2;
c3 = c22 - this;
return(true);
}
c3 = null;
return(false);
}
// indexers
public override void SetValueAt(int i, AltaxoVariant val)
{
if (val.IsTypeOrNull(AltaxoVariant.Content.VDateTime))
{
this[i] = (DateTime)val.m_Object;
}
else
{
throw new ApplicationException("Error: Try to set " + this.TypeAndName + "[" + i + "] with " + val.ToString());
}
}
public override bool vop_Subtraction(AltaxoVariant c2, out DataColumn c3)
{
if (((AltaxoVariant)c2).IsType(AltaxoVariant.Content.VDateTime))
{
DateTime c22 = (DateTime)c2;
c3 = this - c22;
return(true);
}
c3 = null;
return(false);
}
/// <summary>
/// Finds the source row for a given value inside a given row range.
/// </summary>
/// <param name="srcXCol">Column where the value must be found.</param>
/// <param name="xVal">Value to find.</param>
/// <param name="range">Range of rows.</param>
/// <returns>The row for which the element is equal to the value, or -1 if the value could not be found.</returns>
private static int FindSrcXRow(DataColumn srcXCol, AltaxoVariant xVal, ContiguousIntegerRange range)
{
// Find the src row
foreach (int idx in range)
{
if (srcXCol[idx] == xVal)
{
return(idx);
}
}
return(-1);
}
public void Swap(int i, int j)
{
_table.DataColumns.SwapColumnPositions(i, j);
DataColumnCollection prop = _table.PropCols;
for (int n = 0; n < _propColumns; n++)
{
_var = prop[n][i];
prop[n][i] = prop[n][j];
prop[n][j] = _var;
}
}
protected override string SetScaleOrgEnd(Altaxo.Data.AltaxoVariant org, Altaxo.Data.AltaxoVariant end)
{
var o = (DateTime)org;
var e = (DateTime)end;
if (!(o < e))
{
return("org is not less than end");
}
InternalSetOrgEnd(o, e, false, false);
return(null);
}
protected override string SetScaleOrgEnd(Altaxo.Data.AltaxoVariant org, Altaxo.Data.AltaxoVariant end)
{
double o = org.ToDouble();
double e = end.ToDouble();
if (!(o < e))
{
return("org is not less than end");
}
InternalSetOrgEnd(o, e);
return(null);
}
/// <summary>
/// PhysicalVariantToNormal translates physical values into a normal value linear along the axis
/// a physical value of the axis origin must return a value of zero
/// a physical value of the axis end must return a value of one
/// the function physicalToNormal must be provided by any derived class
/// </summary>
/// <param name="x">the physical value</param>
/// <returns>
/// the normalized value linear along the axis,
/// 0 for axis origin, 1 for axis end</returns>
public override double PhysicalVariantToNormal(Altaxo.Data.AltaxoVariant x)
{
if (x.IsType(AltaxoVariant.Content.VDateTime))
{
return(PhysicalToNormal((DateTime)x));
}
else if (x.CanConvertedToDouble)
{
return(PhysicalToNormal(new DateTime((long)(x.ToDouble() * 10000000))));
}
else
{
throw new ArgumentException("Variant x is neither DateTime nor numeric");
}
}
public void Swap(int i, int j)
{
int iNew = _selIndices[i];
int jNew = _selIndices[j];
_table.DataColumns.SwapColumnPositions(iNew, jNew);
DataColumnCollection prop = _table.PropCols;
for (int n = 0; n < _propColumns; n++)
{
_var = prop[n][iNew];
prop[n][iNew] = prop[n][jNew];
prop[n][jNew] = _var;
}
}
public override double PhysicalVariantToNormal(Altaxo.Data.AltaxoVariant x)
{
if (x.IsType(Altaxo.Data.AltaxoVariant.Content.VString))
{
int idx = _dataBounds.IndexOf(x.ToString());
return(idx < 0? double.NaN : (1 + idx - _cachedAxisOrg) * _cachedOneByAxisSpan);
}
else if (x.CanConvertedToDouble)
{
return((x.ToDouble() - _cachedAxisOrg) * _cachedOneByAxisSpan);
}
else
{
return(double.NaN);
}
}
protected override string SetScaleOrgEnd(Altaxo.Data.AltaxoVariant org, Altaxo.Data.AltaxoVariant end)
{
var scaleLinkedTo = ScaleLinkedTo;
if (null != scaleLinkedTo)
{
if (!IsStraightLink)
{
org = (org - LinkOrgA) / LinkOrgB;
end = (end - LinkEndA) / LinkEndB;
}
throw new NotImplementedException("What should we do here?");
//return scaleLinkedTo.SetScaleOrgEnd(org, end);
}
return(null);
}
public override double PhysicalVariantToNormal(Altaxo.Data.AltaxoVariant x)
{
switch (_segmentScaling)
{
case ScaleSegmentType.DifferenceToOrg:
x += _underlyingScale.NormalToPhysicalVariant(_relOrg);
break;
case ScaleSegmentType.RatioToOrg:
x *= _underlyingScale.NormalToPhysicalVariant(_relOrg);
break;
}
double r = _underlyingScale.PhysicalVariantToNormal(x);
return((r - _relOrg) / (_relEnd - _relOrg));
}
} // end of function
private bool CalculateCrossCoordinates(PointD2D crossRootLayerCoord, out Altaxo.Data.AltaxoVariant x, out Altaxo.Data.AltaxoVariant y)
{
var layer = _cachedActiveLayer as XYPlotLayer;
if (layer == null)
{
x = new AltaxoVariant();
y = new AltaxoVariant();
return(false);
}
var layerCoord = _cachedActiveLayerTransformation.InverseTransformPoint(crossRootLayerCoord);
layer.CoordinateSystem.LayerToLogicalCoordinates(layerCoord.X, layerCoord.Y, out var r);
x = layer.XAxis.NormalToPhysicalVariant(r.RX);
y = layer.YAxis.NormalToPhysicalVariant(r.RY);
return(true);
}
} // end of function
void DisplayCrossCoordinates()
{
XYPlotLayer layer = _grac.ActiveLayer;
if (layer == null)
{
return;
}
PointF layerXY = layer.GraphToLayerCoordinates(m_Cross);
Logical3D r;
layer.CoordinateSystem.LayerToLogicalCoordinates(layerXY.X, layerXY.Y, out r);
Altaxo.Data.AltaxoVariant xphys = layer.XAxis.NormalToPhysicalVariant(r.RX);
Altaxo.Data.AltaxoVariant yphys = layer.YAxis.NormalToPhysicalVariant(r.RY);
this.DisplayData(_grac.CurrentLayerNumber, xphys, yphys);
}
public void CopyFrom(DropLinePlotStyle from, Main.EventFiring eventFiring)
{
if (object.ReferenceEquals(this, from))
{
return;
}
using (var suspendToken = SuspendGetToken())
{
_independentSkipFrequency = from._independentSkipFrequency;
_skipFrequency = from._skipFrequency;
_ignoreMissingDataPoints = from._ignoreMissingDataPoints;
_independentOnShiftingGroupStyles = from._independentOnShiftingGroupStyles;
_dropTargets = from._dropTargets; // immutable
_additionalDropTargetIsEnabled = from._additionalDropTargetIsEnabled;
_additionalDropTargetPerpendicularAxis = from._additionalDropTargetPerpendicularAxis;
_additionalDropTargetUsePhysicalBaseValue = from._additionalDropTargetUsePhysicalBaseValue;
_additionalDropTargetBaseValue = from._additionalDropTargetBaseValue;
ChildCopyToMember(ref _pen, from._pen);
_independentColor = from._independentColor;
_independentSymbolSize = from._independentSymbolSize;
_symbolSize = from._symbolSize;
_lineWidth1Offset = from._lineWidth1Offset;
_lineWidth1Factor = from._lineWidth1Factor;
_gapAtStartOffset = from._gapAtStartOffset;
_gapAtStartFactor = from._gapAtStartFactor;
_gapAtEndOffset = from._gapAtEndOffset;
_gapAtEndFactor = from._gapAtEndFactor;
EhSelfChanged(EventArgs.Empty);
suspendToken.Resume(eventFiring);
}
}
int IComparable.CompareTo(object obj)
{
if (!(obj is AltaxoVariant))
{
throw new Exception("Can not compare AltaxoVariant to an object of type " + obj.GetType().ToString());
}
AltaxoVariant from = (AltaxoVariant)obj;
if (this.m_Content != from.m_Content)
{
throw new Exception(string.Format("A variant of type {0} can not be compared to a variant of type {1}", this.m_Content.ToString(), from.m_Content.ToString()));
}
// both have the same content
switch (m_Content)
{
case Content.VNull:
return(0);
case Content.VDouble:
return(m_Double.CompareTo(from.m_Double));
case Content.VDateTime:
return(((DateTime)m_Object).CompareTo(from.m_Object));
case Content.VString:
return(((string)m_Object).CompareTo(from.m_Object));
default:
if (this.m_Object is IComparable)
{
return(((IComparable)this).CompareTo(from.m_Object));
}
else
{
throw new Exception(string.Format("The inner object of this AltaxoVariant (of typeof: {0}) does not implement IComparable", this.m_Object.GetType().ToString()));
}
}
}
} // end of function
bool CalculateCrossCoordinates(out Altaxo.Data.AltaxoVariant x, out Altaxo.Data.AltaxoVariant y)
{
XYPlotLayer layer = _grac.ActiveLayer;
if (layer == null)
{
x = new AltaxoVariant();
y = new AltaxoVariant();
return(false);
}
PointF layerXY = layer.GraphToLayerCoordinates(m_Cross);
Logical3D r;
layer.CoordinateSystem.LayerToLogicalCoordinates(layerXY.X, layerXY.Y, out r);
x = layer.XAxis.NormalToPhysicalVariant(r.RX);
y = layer.YAxis.NormalToPhysicalVariant(r.RY);
return(true);
}
/// <summary>
/// This function searches for patterns like aaa=bbb in the provided string. If it finds such a item, it creates a column named aaa
/// and stores the value bbb at the same position in it as in the text column.
/// </summary>
/// <param name="strg">The string where to search for the patterns described above.</param>
/// <param name="store">The column collection where to store the newly created columns of properties.</param>
/// <param name="index">The index into the column where to store the property value.</param>
public static void ExtractPropertiesFromString(string strg, Altaxo.Data.DataColumnCollection store, int index)
{
string pat;
pat = @"(\S+)=(\S+)";
var r = new Regex(pat, RegexOptions.Compiled | RegexOptions.IgnoreCase);
for (Match m = r.Match(strg); m.Success; m = m.NextMatch())
{
string propname = m.Groups[1].ToString();
string propvalue = m.Groups[2].ToString();
// System.Diagnostics.Trace.WriteLine("Found the pair " + propname + " : " + propvalue);
if (!store.ContainsColumn(propname))
{
Altaxo.Data.DataColumn col;
if (Altaxo.Serialization.DateTimeParsing.IsDateTime(propvalue))
{
col = new Altaxo.Data.DateTimeColumn();
}
else if (Altaxo.Serialization.NumberConversion.IsNumeric(propvalue))
{
col = new Altaxo.Data.DoubleColumn();
}
else
{
col = new Altaxo.Data.TextColumn();
}
store.Add(col, propname); // add the column to the collection
}
// now the column is present we can store the value in it.
store[propname][index] = new Altaxo.Data.AltaxoVariant(propvalue);
}
}
public virtual bool CopyFrom(object obj, bool copyWithDataReferences)
{
if (object.ReferenceEquals(this, obj))
{
return(true);
}
var from = obj as BarGraphPlotStyle;
if (null != from)
{
_usePhysicalBaseValue = from._usePhysicalBaseValue;
_baseValue = from._baseValue;
_startAtPreviousItem = from._startAtPreviousItem;
_previousItemZGap = from._previousItemZGap;
_independentColor = from._independentColor;
_pen = from._pen;
_useUniformCrossSectionThickness = from._useUniformCrossSectionThickness;
_barShiftStrategy = from._barShiftStrategy;
_barShiftMaxNumberOfItemsInOneDirection = from._barShiftMaxNumberOfItemsInOneDirection;
_relInnerGapX = from._relInnerGapX;
_relOuterGapX = from._relOuterGapX;
_relInnerGapY = from._relInnerGapY;
_relOuterGapY = from._relOuterGapY;
_xSizeLogical = from._xSizeLogical;
_xOffsetLogical = from._xOffsetLogical;
_ySizeLogical = from._ySizeLogical;
_yOffsetLogical = from._yOffsetLogical;
EhSelfChanged();
return(true);
}
return(false);
}
/// <summary> /// Calculates the ticks based on the org and end of the scale. Org and End now are given and can not be changed anymore. /// </summary> /// <param name="org">Scale origin.</param> /// <param name="end">Scale end.</param> /// <param name="scale">The scale.</param> public abstract void FinalProcessScaleBoundaries(AltaxoVariant org, AltaxoVariant end, Scale scale);
/// <summary> /// Decides giving a raw org and end value, whether or not the scale boundaries should be extended to /// have more 'nice' values. If the boundaries should be changed, the function return true, and the /// org and end argument contain the proposed new scale boundaries. /// </summary> /// <param name="org">Raw scale org.</param> /// <param name="end">Raw scale end.</param> /// <param name="isOrgExtendable">True when the org is allowed to be extended.</param> /// <param name="isEndExtendable">True when the scale end can be extended.</param> /// <returns>True when org or end are changed. False otherwise.</returns> public abstract bool PreProcessScaleBoundaries(ref AltaxoVariant org, ref AltaxoVariant end, bool isOrgExtendable, bool isEndExtendable);
protected override string FormatItem(AltaxoVariant item)
{
if (!string.IsNullOrEmpty(_formatString))
{
try
{
return string.Format(_formatString, item.ToObject());
}
catch (Exception)
{
}
}
return item.ToString();
}
public override bool vop_GreaterOrEqual(AltaxoVariant c2, out DataColumn c3)
{
if (((AltaxoVariant)c2).IsType(AltaxoVariant.Content.VDouble))
{
double c22 = (double)c2;
c3 = this >= c22;
return true;
}
c3 = null;
return false;
}
/// <summary>Initializes a new instance of the <see cref="LocalArrayHolder"/> class.</summary>
/// <param name="localArray">The local array of transformed y values. The array length is equal to the number of plot points.</param>
/// <param name="pdata">The processed plot data. The plot range member of this instance is used to build a dictionary which associates the original row indices to the indices of the <paramref name="localArray"/>.</param>
public LocalArrayHolder(AltaxoVariant[] localArray, Processed3DPlotData pdata)
{
_localArray = localArray;
_originalRowIndexToPlotIndex = pdata.RangeList.GetDictionaryOfOriginalRowIndicesToPlotIndices();
}
/// <summary>
/// Determines whether the plot items in <paramref name="coll"/> can be plotted as stack. Presumption is that all plot items
/// have the same number of plot points, and that all items have the same order of x values associated with the plot points.
/// </summary>
/// <param name="layer">Plot layer.</param>
/// <param name="coll">Collection of plot items.</param>
/// <param name="plotDataList">Output: dictionary with associates each plot item with a list of processed plot data.</param>
/// <returns>Returns <c>true</c> if the plot items in <paramref name="coll"/> can be plotted as stack; otherwise, <c>false</c>.</returns>
public static bool CanUseStyle(IPlotArea layer, PlotItemCollection coll, out Dictionary<G3DPlotItem, Processed3DPlotData> plotDataList)
{
plotDataList = new Dictionary<G3DPlotItem, Processed3DPlotData>();
AltaxoVariant[] xArray = null;
AltaxoVariant[] yArray = null;
int idx = -1;
foreach (IGPlotItem pi in coll)
{
if (pi is G3DPlotItem)
{
idx++;
G3DPlotItem gpi = (G3DPlotItem)pi;
Processed3DPlotData pdata = gpi.GetRangesAndPoints(layer);
plotDataList.Add(gpi, pdata);
if (xArray == null)
{
xArray = new AltaxoVariant[pdata.RangeList.PlotPointCount];
yArray = new AltaxoVariant[pdata.RangeList.PlotPointCount];
int j = -1;
foreach (int originalIndex in pdata.RangeList.OriginalRowIndices())
{
j++;
xArray[j] = pdata.GetXPhysical(originalIndex);
yArray[j] = pdata.GetYPhysical(originalIndex);
}
}
else // this is not the first item
{
if (pdata.RangeList.PlotPointCount != xArray.Length)
return false;
int j = -1;
foreach (int originalIndex in pdata.RangeList.OriginalRowIndices())
{
j++;
if (xArray[j] != pdata.GetXPhysical(originalIndex))
return false;
if (yArray[j] != pdata.GetYPhysical(originalIndex))
return false;
}
}
}
}
return idx >= 1;
}
private string DefaultDoubleConverter(AltaxoVariant x)
{
return ((double)x).ToString("r", _formatProvider);
}
public override bool vop_Division_Rev(AltaxoVariant c2, out DataColumn c3)
{
if (((AltaxoVariant)c2).IsType(AltaxoVariant.Content.VDouble))
{
double c22 = (double)c2;
c3 = c22 / this;
return true;
}
c3 = null;
return false;
}
public override Altaxo.Data.AltaxoVariant[] GetMinorTicksAsVariant()
{
AltaxoVariant[] result = new AltaxoVariant[_dataBounds.NumberOfItems + 1];
for (int i = 0; i < result.Length; i++)
result[i] = new Altaxo.Data.AltaxoVariant(i + 0.5);
return result;
}
public override bool vop_Multiplication_Rev(AltaxoVariant c2, out DataColumn c3)
{
return vop_Multiplication(c2, out c3);
}
public override bool vop_Multiplication(AltaxoVariant c2, out DataColumn c3)
{
if (((AltaxoVariant)c2).IsType(AltaxoVariant.Content.VDouble))
{
double c22 = (double)c2;
c3 = this * c22;
return true;
}
c3 = null;
return false;
}
/// <summary>
/// Measures a couple of items and prepares them for being drawn.
/// </summary>
/// <param name="g">Graphics context.</param>
/// <param name="font">Font used.</param>
/// <param name="strfmt">String format used.</param>
/// <param name="items">Array of items to be drawn.</param>
/// <returns>An array of <see cref="IMeasuredLabelItem" /> that can be used to determine the size of each item and to draw it.</returns>
public override IMeasuredLabelItem[] GetMeasuredItems(IGraphicsContext3D g, FontX3D font, AltaxoVariant[] items)
{
string[] titems = FormatItems(items);
if (!string.IsNullOrEmpty(_prefix) || !string.IsNullOrEmpty(_suffix))
{
for (int i = 0; i < titems.Length; ++i)
titems[i] = _prefix + titems[i] + _suffix;
}
MeasuredLabelItem[] litems = new MeasuredLabelItem[titems.Length];
FontX3D localfont = font;
for (int i = 0; i < titems.Length; ++i)
{
litems[i] = new MeasuredLabelItem(g, localfont, titems[i], _relativeLineSpacing, Alignment.Near, Alignment.Near, _textBlockAlignment);
}
return litems;
}
} // end of function
private bool CalculateCrossCoordinates(PointD2D crossRootLayerCoord, out Altaxo.Data.AltaxoVariant x, out Altaxo.Data.AltaxoVariant y)
{
XYPlotLayer layer = _cachedActiveLayer as XYPlotLayer;
if (layer == null)
{
x = new AltaxoVariant();
y = new AltaxoVariant();
return false;
}
var layerCoord = _cachedActiveLayerTransformation.InverseTransformPoint(crossRootLayerCoord);
Logical3D r;
layer.CoordinateSystem.LayerToLogicalCoordinates(layerCoord.X, layerCoord.Y, out r);
x = layer.XAxis.NormalToPhysicalVariant(r.RX);
y = layer.YAxis.NormalToPhysicalVariant(r.RY);
return true;
}
public override AltaxoVariant[] GetMinorTicksAsVariant()
{
double[] ticks = GetMinorTicks();
AltaxoVariant[] vticks = new AltaxoVariant[ticks.Length];
for (int i = 0; i < ticks.Length; ++i)
vticks[i] = ticks[i];
return vticks;
}
private string DefaultTextConverter(AltaxoVariant x)
{
string s = x.ToString();
s = s.Replace('\r', ' ');
s = s.Replace('\n', ' ');
return s;
}
public virtual bool CopyFrom(object obj, bool copyWithDataReferences)
{
if (object.ReferenceEquals(this, obj))
return true;
var from = obj as BarGraphPlotStyle;
if (null != from)
{
this._usePhysicalBaseValue = from._usePhysicalBaseValue;
this._baseValue = from._baseValue;
this._startAtPreviousItem = from._startAtPreviousItem;
this._previousItemZGap = from._previousItemZGap;
this._independentColor = from._independentColor;
this._pen = from._pen;
this._useUniformCrossSectionThickness = from._useUniformCrossSectionThickness;
this._barShiftStrategy = from._barShiftStrategy;
this._barShiftMaxNumberOfItemsInOneDirection = from._barShiftMaxNumberOfItemsInOneDirection;
this._relInnerGapX = from._relInnerGapX;
this._relOuterGapX = from._relOuterGapX;
this._relInnerGapY = from._relInnerGapY;
this._relOuterGapY = from._relOuterGapY;
this._xSizeLogical = from._xSizeLogical;
this._xOffsetLogical = from._xOffsetLogical;
this._ySizeLogical = from._ySizeLogical;
this._yOffsetLogical = from._yOffsetLogical;
EhSelfChanged();
return true;
}
return false;
}
private string DefaultDateTimeConverter(AltaxoVariant x)
{
return ((DateTime)x).ToString("o");
}
// indexers
public override void SetValueAt(int i, AltaxoVariant val)
{
if(val.IsTypeOrNull(AltaxoVariant.Content.VString))
this[i] = (string)val;
else
this[i] = val.ToString();
// throw new ApplicationException("Error: Try to set " + this.TypeAndName + "[" + i + "] with " + val.ToString());
}
/// <summary>Adds the y-values of a plot item to an array of y-values..</summary>
/// <param name="vArray">The y array to be added to. If null, a new array will be allocated (and filled with the y-values of the plot item).</param>
/// <param name="pdata">The pdata.</param>
/// <returns>If the parameter <paramref name="vArray"/> was not null, then that <paramref name="vArray"/> is returned. Otherwise the newly allocated array is returned.</returns>
public static AltaxoVariant[] AddUp(AltaxoVariant[] vArray, Processed3DPlotData pdata)
{
if (vArray == null)
{
vArray = new AltaxoVariant[pdata.RangeList.PlotPointCount];
int j = -1;
foreach (int originalIndex in pdata.RangeList.OriginalRowIndices())
{
j++;
vArray[j] = pdata.GetZPhysical(originalIndex);
}
}
else // this is not the first item
{
int j = -1;
foreach (int originalIndex in pdata.RangeList.OriginalRowIndices())
{
j++;
vArray[j] += pdata.GetZPhysical(originalIndex);
}
}
return vArray;
}
// indexers
public override void SetValueAt(int i, AltaxoVariant val)
{
if(val.IsType(AltaxoVariant.Content.VDouble))
this[i] = val.m_Double;
else if(val.CanConvertedToDouble)
this[i] = val.ToDouble();
else
throw new ApplicationException("Error: Try to set " + this.TypeAndName + "[" + i + "] with the string " + val.ToString());
}
public CSLineID(CSLineID from)
{
this._parallelAxisNumber = from._parallelAxisNumber;
this._logicalValueFirstOther = from._logicalValueFirstOther;
this._usePhysicalValueFirstOther = from._usePhysicalValueFirstOther;
this._physicalValueFirstOther = from._physicalValueFirstOther;
this._logicalValueSecondOther = from._logicalValueSecondOther;
this._usePhysicalValueSecondOther = from._usePhysicalValueSecondOther;
this._physicalValueSecondOther = from._physicalValueSecondOther;
}
public override bool vop_ShiftRight_Rev(AltaxoVariant c2, out DataColumn c3)
{
if (((AltaxoVariant)c2).IsType(AltaxoVariant.Content.VDouble))
{
DoubleColumn c1 = this;
int len = c1._count;
Altaxo.Data.DoubleColumn c33 = new Altaxo.Data.DoubleColumn(len);
long c22 = (long)(double)c2;
for (int i = 0; i < len; i++)
c33._data[i] = c22 >> ((int)c1._data[i]);
c33._count = len;
c3 = c33;
return true;
}
c3 = null;
return false;
}
/// <summary>
/// calculates the axis org and end using the databounds
/// the org / end is adjusted only if it is not fixed
/// and the DataBound object contains valid data
/// </summary>
public override void ProcessDataBounds(AltaxoVariant org, bool orgfixed, AltaxoVariant end, bool endfixed)
{
double dorg = org.ToDouble();
double dend = end.ToDouble();
ProcessDataBounds(dorg, orgfixed, dend, endfixed);
}
/// <summary>
/// Initialized a 2D identifier from the parallel axis and the physical value of the perpendicular axis.
/// </summary>
/// <param name="parallelAxisNumber">Number of parallel axis (0->X, 1->Y, 2->Z).</param>
/// <param name="physicalValueOther">Physical value of the axis perendicular to the parallel axis.</param>
/// <returns>A freshly created 2D line identifier.</returns>
public static CSLineID FromPhysicalVariant(int parallelAxisNumber, AltaxoVariant physicalValueOther)
{
if (parallelAxisNumber < 0 || parallelAxisNumber > 2)
throw new ArgumentOutOfRangeException("AxisNumber must be either 0, 1, or 2, but you provide: " + parallelAxisNumber.ToString());
if (!physicalValueOther.Equals(physicalValueOther))
throw new ArgumentException("You can not set physical values that return false when compared to itself, value is: " + physicalValueOther.ToString());
CSLineID id = new CSLineID();
id._parallelAxisNumber = parallelAxisNumber;
id._physicalValueFirstOther = physicalValueOther;
id._logicalValueFirstOther = double.NaN;
id._usePhysicalValueFirstOther = true;
id._logicalValueSecondOther = double.NaN;
return id;
}
public void CopyFrom(DropLinePlotStyle from, Main.EventFiring eventFiring)
{
if (object.ReferenceEquals(this, from))
return;
using (var suspendToken = SuspendGetToken())
{
this._independentSkipFreq = from._independentSkipFreq;
this._skipFreq = from._skipFreq;
this._dropTargets = from._dropTargets; // immutable
this._additionalDropTargetIsEnabled = from._additionalDropTargetIsEnabled;
this._additionalDropTargetPerpendicularAxis = from._additionalDropTargetPerpendicularAxis;
this._additionalDropTargetUsePhysicalBaseValue = from._additionalDropTargetUsePhysicalBaseValue;
this._additionalDropTargetBaseValue = from._additionalDropTargetBaseValue;
this._pen = from._pen; // immutable
this._independentColor = from._independentColor;
_independentSymbolSize = from._independentSymbolSize;
_symbolSize = from._symbolSize;
_lineWidth1Offset = from._lineWidth1Offset;
_lineWidth1Factor = from._lineWidth1Factor;
_lineWidth2Offset = from._lineWidth2Offset;
_lineWidth2Factor = from._lineWidth2Factor;
this._gapAtStartOffset = from._gapAtStartOffset;
this._gapAtStartFactor = from._gapAtStartFactor;
this._gapAtEndOffset = from._gapAtEndOffset;
this._gapAtEndFactor = from._gapAtEndFactor;
EhSelfChanged(EventArgs.Empty);
suspendToken.Resume(eventFiring);
}
}
public void Add(AltaxoVariant additionalTick)
{
_additionalTicks.Add(additionalTick);
EhSelfChanged();
}
public override bool vop_ShiftLeft(AltaxoVariant c2, out DataColumn c3)
{
if (((AltaxoVariant)c2).IsType(AltaxoVariant.Content.VDouble))
{
int c22 = (int)(double)c2;
c3 = this << c22;
return true;
}
c3 = null;
return false;
}
public override bool vop_ShiftRight(AltaxoVariant c2, out DataColumn c3)
{
if(((AltaxoVariant)c2).IsType(AltaxoVariant.Content.VDouble))
{
DoubleColumn c1=this;
int len = c1.m_Count;
Altaxo.Data.DoubleColumn c33 = new Altaxo.Data.DoubleColumn(len);
int c22 = (int)(double)c2;
for(int i=0;i<len;i++)
c33.m_Array[i] = ((long)c1.m_Array[i]) >> c22;
c33.m_Count = len;
c3=c33;
return true;
}
c3=null;
return false;
}