public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
{
PlotItemCollection s = (PlotItemCollection)obj;
info.CreateArray("PlotItems", s.Count);
for (int i = 0; i < s.Count; i++)
{
info.AddValue("PlotItem", s[i]);
}
info.CommitArray();
info.AddValue("GroupStyles", s._styles);
}
/// <summary>
/// Copy constructor. Clones (!) all the items in the list.
/// </summary>
/// <param name="owner">The new owner of the cloned list.</param>
/// <param name="from">The list to clone all items from.</param>
public PlotItemCollection(XYPlotLayer owner, PlotItemCollection from)
{
_parent = owner;
_styles = new PlotGroupStyleCollection();
_plotItems = new List <IGPlotItem>();
// Clone all the items in the list.
for (int i = 0; i < from.Count; i++)
{
Add((IGPlotItem)from[i].Clone()); // clone the items
}
// special way neccessary to handle plot groups
this._styles = null == from._styles ? null : from._styles.Clone();
}
/// <summary>
/// Prepare styles forward, but only up in the hierarchy.
/// </summary>
/// <param name="parentstyles">The parent group style collection.</param>
/// <param name="layer">The plot layer.</param>
protected void PrepareStylesForward_HierarchyUpOnly(PlotGroupStyleCollection parentstyles, IPlotArea layer)
{
bool transferFromParentStyles =
parentstyles != null &&
parentstyles.Count != 0 &&
parentstyles.DistributeToChildGroups &&
this._styles.InheritFromParentGroups;
_styles.BeginPrepare();
string thisname = Main.DocumentPath.GetPathString(this, int.MaxValue);
System.Diagnostics.Debug.WriteLine(string.Format("{0}:Begin:PrepareFWHUO", thisname));
if (transferFromParentStyles)
{
PlotGroupStyleCollection.TransferFromTo(parentstyles, _styles);
System.Diagnostics.Debug.WriteLine(string.Format("{0}:Begin:PrepareFWHUO (transfer from parent style", thisname));
}
// now distibute the styles from the first item down to the last item
int last = _plotItems.Count - 1;
for (int i = 0; i <= last; i++)
{
IGPlotItem pi = _plotItems[i];
if (pi is PlotItemCollection)
{
PlotItemCollection pic = (PlotItemCollection)pi;
pic.PrepareStylesForward_HierarchyUpOnly(_styles, layer);
_styles.PrepareStepIfForeignSteppingFalse(((PlotItemCollection)pi)._styles);
}
else
{
pi.PrepareStyles(_styles, layer);
_styles.PrepareStep();
}
}
if (transferFromParentStyles)
{
PlotGroupStyleCollection.TransferFromTo(_styles, parentstyles);
System.Diagnostics.Debug.WriteLine(string.Format("{0}:End:PrepareFWHUO (transfer back to parent style", thisname));
}
_styles.EndPrepare();
System.Diagnostics.Debug.WriteLine(string.Format("{0}:End:PrepareFWHUO", thisname));
}
/// <summary>
/// Apply styles, beginning at item 'pivotidx' in this collection, iterative backwards up and down the hierarchy.
/// It stops at the first item of a collection here or down the hierarchy that do not inherit from it's parent collection.
/// </summary>
/// <param name="pivotidx">The index of the item where the application process starts.</param>
/// <returns>The plot item collection where the process stops.</returns>
protected PlotItemCollection ApplyStylesIterativeBackward(int pivotidx)
{
// if the pivot is lower than 0, we first distibute all changes to the first item and
// then from the first item again down the line
if (pivotidx > 0)
{
_styles.BeginApply();
for (int i = pivotidx; i >= 0; i--)
{
IGPlotItem pi = _plotItems[i];
if (pi is PlotItemCollection)
{
_styles.Step(-1);
PlotItemCollection pic = (PlotItemCollection)pi;
pic.ApplyStylesBackward_HierarchyUpOnly(_styles);
}
else
{
pi.ApplyStyles(_styles);
if (i > 0)
{
_styles.Step(-1);
}
}
}
_styles.EndApply();
}
// now use this styles to copy to the parent
bool transferToParentStyles =
ParentCollection != null &&
ParentCollection._styles.Count != 0 &&
ParentCollection._styles.DistributeToChildGroups &&
this._styles.InheritFromParentGroups;
PlotItemCollection rootCollection = this;
if (transferToParentStyles)
{
PlotGroupStyleCollection.TransferFromTo(_styles, ParentCollection._styles);
rootCollection = ParentCollection.ApplyStylesIterativeBackward(ParentCollection._styles.Count - 1);
}
return(rootCollection);
}
public object Deserialize(object o, Altaxo.Serialization.Xml.IXmlDeserializationInfo info, object parent)
{
PlotItemCollection s = null != o ? (PlotItemCollection)o : new PlotItemCollection();
int count = info.OpenArray();
IGPlotItem[] plotItems = new IGPlotItem[count];
for (int i = 0; i < count; i++)
{
s.Add((IGPlotItem)info.GetValue("PlotItem", s));
}
info.CloseArray(count);
s._styles = (PlotGroupStyleCollection)info.GetValue("GroupStyles", s);
return(s);
}
/// <summary>
/// Distribute the changes made to the plotitem 'pivotitem' to all other items in the collection and if neccessary, also up and down the plot item tree.
/// </summary>
/// <param name="pivotitem">The plot item where changes to the plot item's styles were made.</param>
public void DistributeChanges(IGPlotItem pivotitem)
{
int pivotidx = _plotItems.IndexOf(pivotitem);
if (pivotidx < 0)
{
return;
}
// Distribute the changes backward to the first item
PrepareStylesIterativeBackward(pivotidx, this.ParentLayer);
PlotItemCollection rootCollection = ApplyStylesIterativeBackward(pivotidx);
// now prepare and apply the styles forward normally beginning from the root collection
// we can set the parent styles to null since rootCollection is the lowest collection that don't inherit from a lower group.
rootCollection.PrepareStylesForward_HierarchyUpOnly(null, this.ParentLayer);
rootCollection.ApplyStylesForward_HierarchyUpOnly(null);
}
/// <summary>
/// Apply styles forward, but only up in the hierarchy.
/// </summary>
/// <param name="parentstyles">The parent group style collection.</param>
protected void ApplyStylesForward_HierarchyUpOnly(PlotGroupStyleCollection parentstyles)
{
bool transferFromParentStyles =
parentstyles != null &&
parentstyles.Count != 0 &&
parentstyles.DistributeToChildGroups &&
this._styles.InheritFromParentGroups;
if (transferFromParentStyles)
{
PlotGroupStyleCollection.TransferFromTo(parentstyles, _styles);
}
_styles.BeginApply();
// now distibute the styles from the first item down to the last item
int last = _plotItems.Count - 1;
for (int i = 0; i <= last; i++)
{
IGPlotItem pi = _plotItems[i];
if (pi is PlotItemCollection)
{
PlotItemCollection pic = (PlotItemCollection)pi;
pic.ApplyStylesForward_HierarchyUpOnly(_styles);
_styles.StepIfForeignSteppingFalse(1, ((PlotItemCollection)pi)._styles);
}
else
{
pi.ApplyStyles(_styles);
_styles.Step(1);
}
}
_styles.EndApply();
if (transferFromParentStyles)
{
PlotGroupStyleCollection.TransferFromToIfBothSteppingEnabled(_styles, parentstyles);
parentstyles.SetAllToApplied(); // to indicate that we have applied this styles and so to enable stepping
}
}
public object Deserialize(object o, Altaxo.Serialization.Xml.IXmlDeserializationInfo info, object parent)
{
PlotItemCollection s = null != o ? (PlotItemCollection)o : new PlotItemCollection();
int count = info.OpenArray();
IGPlotItem[] plotItems = new IGPlotItem[count];
for (int i = 0; i < count; i++)
{
plotItems[i] = (IGPlotItem)info.GetValue("PlotItem", s);
}
info.CloseArray(count);
count = info.OpenArray(); // PlotGroups
PGTrans[] plotGroups = new PGTrans[count];
for (int i = 0; i < count; i++)
{
plotGroups[i].PlotGroup = (PlotGroupMemento)info.GetValue(s);
}
info.CloseArray(count);
// now assemble the new tree based collection based on the both fields
for (int pix = 0; pix < plotItems.Length; pix++)
{
// look if this plotItem is member of some group
int foundidx = -1;
for (int grx = 0; grx < plotGroups.Length; grx++)
{
if (Array.IndexOf <int>(plotGroups[grx].PlotGroup._plotItemIndices, pix) >= 0)
{
foundidx = grx;
break;
}
}
if (foundidx < 0) // if not found in some group, add the item directly
{
s.Add(plotItems[pix]);
}
else
{
if (plotGroups[foundidx].PlotItemCollection == null)
{
PlotItemCollection newColl = new PlotItemCollection();
plotGroups[foundidx].PlotItemCollection = newColl;
s.Add(plotGroups[foundidx].PlotItemCollection);
// now set the properties of this new collection
bool serial = !plotGroups[foundidx].PlotGroup._concurrently;
IPlotGroupStyle curr = null;
IPlotGroupStyle prev = null;
if (0 != (plotGroups[foundidx].PlotGroup._plotGroupStyle & Version0PlotGroupStyle.Color))
{
curr = new ColorGroupStyle();
newColl.GroupStyles.Add(curr);
}
if (0 != (plotGroups[foundidx].PlotGroup._plotGroupStyle & Version0PlotGroupStyle.Line))
{
prev = curr;
curr = new LineStyleGroupStyle();
newColl.GroupStyles.Add(curr, serial ? (prev == null?null:prev.GetType()) : null);
}
if (0 != (plotGroups[foundidx].PlotGroup._plotGroupStyle & Version0PlotGroupStyle.Symbol))
{
prev = curr;
curr = new SymbolShapeStyleGroupStyle();
newColl.GroupStyles.Add(curr, serial ? (prev == null ? null : prev.GetType()) : null);
}
}
// now add the item to this collection
plotGroups[foundidx].PlotItemCollection.Add(plotItems[pix]);
}
}
return(s);
}
/// <summary>
/// Copy constructor. Clones (!) all items. The parent owner is set to null and has to be set afterwards.
/// </summary>
/// <param name="from">The PlotItemCollection to clone this list from.</param>
public PlotItemCollection(PlotItemCollection from)
:
this(null, from)
{
}
