/// <inheritdoc/>
public override void Deserialize(FRReader reader)
{
base.Deserialize(reader);
points = new List <PointF>();
pointTypes = new List <byte>();
string polyPoints = reader.ReadStr("PolyPoints");
foreach (string str in polyPoints.Split('|'))
{
string[] point = str.Split('\\');
if (point.Length == 3)
{
float f1 = float.Parse(point[0].Replace(',', '.'), CultureInfo.InvariantCulture);
float f2 = float.Parse(point[1].Replace(',', '.'), CultureInfo.InvariantCulture);
addPoint(f1, f2, byte.Parse(point[2]));
}
}
if (reader.HasProperty("CenterX"))
{
center.X = reader.ReadFloat("CenterX");
}
if (reader.HasProperty("CenterY"))
{
center.Y = reader.ReadFloat("CenterY");
}
//recalculateBounds();
}
/// <inheritdoc/>
public override void Deserialize(FRReader reader)
{
base.Deserialize(reader);
// compatibility with old reports: try to use last part of ReferenceName as a value for PropName
if (!String.IsNullOrEmpty(ReferenceName) && ReferenceName.Contains("."))
{
string[] names = ReferenceName.Split(new char[] { '.' });
PropName = names[names.Length - 1];
ReferenceName = "";
}
// gather all nested datasource names (PropName properties)
List <string> dataSourceNames = new List <string>();
foreach (Column column in Columns)
{
if (column is BusinessObjectDataSource)
{
dataSourceNames.Add(column.PropName);
}
}
// delete simple columns that have the same name as a datasource. In old version,
// there was an invisible column used to support BO infrastructure
for (int i = 0; i < Columns.Count; i++)
{
Column column = Columns[i];
if (!(column is BusinessObjectDataSource) && dataSourceNames.Contains(column.PropName))
{
column.Dispose();
i--;
}
}
}
//static int i = 0;
/// <summary>
/// Assigns values from another source.
/// </summary>
/// <remarks>
/// <b>Note:</b> this method is relatively slow because it serializes
/// an object to the xml and then deserializes it.
/// </remarks>
/// <param name="source">Source to assign from.</param>
public void BaseAssign(Base source)
{
bool saveAncestor = source.IsAncestor;
source.SetAncestor(false);
try
{
using (XmlItem xml = new XmlItem())
using (FRWriter writer = new FRWriter(xml))
using (FRReader reader = new FRReader(Report, xml))
{
writer.SaveChildren = false;
writer.Write(source, this);
reader.Read(this);
}
Alias = source.Alias;
OriginalComponent = source.OriginalComponent;
}
finally
{
source.SetAncestor(saveAncestor);
}
}
/// <inheritdoc/>
public override void Deserialize(FRReader reader)
{
// the Clear is needed to avoid duplicate columns in the inherited report
// when the same datasource is exists in both base and inherited report
Clear();
base.Deserialize(reader);
}
internal ReportPage StartGetPage(int index)
{
Load();
ReportPage page;
using (FRReader reader = new FRReader(null))
{
reader.ReadChildren = false;
reader.BlobStore = preparedPages.BlobStore;
page = ReadPage(null, xmlItem, false, reader);
if (!(page.UnlimitedHeight || page.UnlimitedWidth))
{
page.Dispose();
page = ReadPage(null, xmlItem, true, reader);
page.SetReport(preparedPages.Report);
posprocessor = new PreparedPagePosprocessor();
posprocessor.Postprocess(page);
posprocessor = null;
}
else
{
page.SetReport(preparedPages.Report);
posprocessor = new PreparedPagePosprocessor();
posprocessor.PostprocessUnlimited(this, page);
}
}
if (page.MirrorMargins && (index + 1) % 2 == 0)
{
float f = page.LeftMargin;
page.LeftMargin = page.RightMargin;
page.RightMargin = f;
}
return(page);
}
private Base CloneObjects(Base source, Base parent)
{
if (source is ReportComponentBase && !(source as ReportComponentBase).FlagPreviewVisible)
{
return(null);
}
// create clone object and assign all properties from source
string baseName = "";
string objName;
Base clone = Activator.CreateInstance(source.GetType()) as Base;
using (XmlItem xml = new XmlItem())
using (FRWriter writer = new FRWriter(xml))
using (FRReader reader = new FRReader(null, xml))
{
writer.SaveChildren = false;
writer.SerializeTo = SerializeTo.SourcePages;
writer.Write(source, clone);
reader.Read(clone);
}
clone.Name = source.Name;
clone.OriginalComponent = source;
source.OriginalComponent = clone;
if (clone is ReportComponentBase)
{
(clone as ReportComponentBase).AssignPreviewEvents(source);
}
// create alias
objName = "Page" + pages.Count.ToString() + "." + clone.Name;
if (clone is BandBase)
{
baseName = "b";
}
else if (clone is PageBase)
{
baseName = "page";
objName = "Page" + pages.Count.ToString();
}
else
{
baseName = clone.BaseName[0].ToString().ToLower();
}
clone.Alias = preparedPages.Dictionary.AddUnique(baseName, objName, clone);
source.Alias = clone.Alias;
ObjectCollection childObjects = source.ChildObjects;
foreach (Base c in childObjects)
{
CloneObjects(c, clone);
}
clone.Parent = parent;
return(clone);
}
/// <summary>
/// Deserializes the object.
/// </summary>
/// <remarks>
/// <para>Do not call this method directly. You should override it if you are
/// developing a new component for FastReport.</para>
/// <para>This method is called when the object needs to restore the state. It may
/// happen when:</para>
/// <list type="bullet">
/// <item>
/// <description>loading the report from a file or stream;</description>
/// </item>
/// <item>
/// <description>loading the report from the designer's undo
/// buffer;</description>
/// </item>
/// <item>
/// <description>assigning another object to this object using the
/// <see cref="Assign"/> or <see cref="AssignAll(Base)">AssignAll</see> methods;</description>
/// </item>
/// <item>
/// <description>loading the object from the designer's
/// clipboard;</description>
/// </item>
/// <item>loading the object from the preview pages.</item>
/// </list>
/// </remarks>
/// <param name="reader">Reader object.</param>
public virtual void Deserialize(FRReader reader)
{
reader.ReadProperties(this);
while (reader.NextItem())
{
DeserializeSubItems(reader);
}
}
/// <summary>
/// Loads the collection from a stream.
/// </summary>
/// <param name="stream">Stream to load from.</param>
public void Load(Stream stream)
{
using (FRReader reader = new FRReader(null))
{
reader.Load(stream);
reader.Read(this);
}
}
/// <inheritdoc/>
public override void Deserialize(FRReader reader)
{
base.Deserialize(reader);
if (reader.HasProperty("GroupByXValue"))
{
GroupBy = GroupBy.XValue;
}
}
/// <summary>
/// Deserializes the collection.
/// </summary>
/// <param name="reader">Reader object.</param>
/// <remarks>
/// This method is for internal use only.
/// </remarks>
public void Deserialize(FRReader reader)
{
while (reader.NextItem())
{
StyleCollection s = new StyleCollection();
reader.Read(s);
Add(s);
}
}
/// <inheritdoc/>
public void Deserialize(FRReader reader)
{
Clear();
while (reader.NextItem())
{
FormatBase format = reader.Read() as FormatBase;
Add(format);
}
}
private void RestoreSettings()
{
XmlItem root = Config.Root.FindItem("Preview").FindItem("Exports").FindItem(ClassName);
using (FRReader reader = new FRReader(null, root))
{
reader.Read(this);
}
}
/// <summary>
/// Loads the dictionary from a stream.
/// </summary>
/// <param name="stream">The stream to load from.</param>
public void Load(Stream stream)
{
Clear();
using (FRReader reader = new FRReader(Report))
{
reader.Load(stream);
reader.Read(this);
}
}
/// <inheritdoc/>
public void Deserialize(FRReader reader)
{
Clear();
while (reader.NextItem())
{
MatrixHeaderDescriptor d = new MatrixHeaderDescriptor();
reader.Read(d);
Add(d);
}
}
/// <summary>
/// Deserializes the collection.
/// </summary>
/// <param name="reader">Reader object.</param>
/// <remarks>
/// This method is for internal use only.
/// </remarks>
public void Deserialize(FRReader reader)
{
Clear();
while (reader.NextItem())
{
GridControlColumn c = new GridControlColumn();
reader.Read(c);
Add(c);
}
}
internal string GetName()
{
using (FRReader reader = new FRReader(null))
{
reader.ReadChildren = false;
reader.BlobStore = preparedPages.BlobStore;
ReportPage page = ReadObject(null, xmlItem, false, reader) as ReportPage;
return(page.Name);
}
}
/// <inheritdoc/>
public void Deserialize(FRReader reader)
{
Clear();
while (reader.NextItem())
{
HighlightCondition c = new HighlightCondition();
reader.Read(c);
Add(c);
}
}
/// <inheritdoc/>
public void Deserialize(FRReader reader)
{
Clear();
while (reader.NextItem())
{
CrossViewCellDescriptor d = new CrossViewCellDescriptor();
reader.Read(d);
Add(d);
}
}
/// <inheritdoc/>
public void Deserialize(FRReader reader)
{
Clear();
while (reader.NextItem())
{
Sort s = new Sort();
reader.Read(s);
Add(s);
}
}
internal IEnumerable <Base> GetPageItems(ReportPage page, bool postprocess)
{
if (!(page.UnlimitedHeight || page.UnlimitedWidth))
{
foreach (Base child in page.ChildObjects)
{
if (postprocess)
{
yield return(child);
}
else
{
using (child)
yield return(child);
}
}
}
else
{
if (Export.ExportBase.HAVE_TO_WORK_WITH_OVERLAY)
#pragma warning disable CS0162 // Unreachable code detected
{
foreach (Base child in page.ChildObjects)
#pragma warning restore CS0162 // Unreachable code detected
{
if (child is OverlayBand)
{
yield return(child);
}
}
}
using (FRReader reader = new FRReader(null))
{
reader.DeserializeFrom = SerializeTo.Preview;
reader.ReadChildren = false;
reader.BlobStore = preparedPages.BlobStore;
for (int i = 0; i < xmlItem.Count; i++)
{
if (postprocess)
{
yield return(ReadObject(page, xmlItem[i], true, reader));
}
else
{
using (Base obj = ReadObject(page, xmlItem[i], true, reader))
{
using (Base obj2 = posprocessor.PostProcessBandUnlimitedPage(obj))
yield return(obj2);
}
}
}
}
}
}
private void LoadReport(Stream stream)
{
Report.Clear();
using (FRReader reader = new FRReader(Report))
{
stream.Position = 0;
reader.BlobStore = BlobStore;
reader.Load(stream);
reader.Read(Report);
}
}
/// <inheritdoc/>
protected override void DeserializeSubItems(FRReader reader)
{
if (String.Compare(reader.ItemName, "Formats", true) == 0)
{
reader.Read(Formats);
}
else
{
base.DeserializeSubItems(reader);
}
}
public void Load(XmlItem rootItem)
{
Clear();
for (int i = 0; i < rootItem.Count; i++)
{
using (FRReader reader = new FRReader(null, rootItem[i]))
{
pages.Add(reader.Read() as ReportPage);
}
}
}
public override void Deserialize(FRReader reader)
{
FPageType = RegisteredObjects.FindType(reader.ReadStr("PageType"));
while (reader.NextItem())
{
Base c = reader.Read() as Base;
if (c != null)
{
FObjects.Add(c);
}
}
}
/// <inheritdoc/>
public override void Deserialize(FRReader reader, string prefix)
{
base.Deserialize(reader, prefix);
if (reader.HasProperty(prefix + ".ImageIndex"))
{
imageIndex = reader.ReadInt(prefix + ".ImageIndex");
}
if (reader.BlobStore != null && imageIndex != -1)
{
SetImageData(reader.BlobStore.Get(imageIndex));
}
}
/// <inheritdoc/>
public void Deserialize(FRReader reader)
{
Clear();
Name = "";
reader.ReadProperties(this);
while (reader.NextItem())
{
Style s = new Style();
reader.Read(s);
Add(s);
}
}
internal ReportPage ReadPage(Base parent, XmlItem item, bool readchild, FRReader reader)
{
ReportPage page = ReadObject(parent, item, false, reader) as ReportPage;
if (readchild)
{
for (int i = 0; i < item.Count; i++)
{
ReadObject(page, item[i], true, reader);
}
}
return(page);
}
/// <inheritdoc/>
public override void Deserialize(FRReader reader)
{
base.Deserialize(reader);
if (reader.HasProperty("ChartData"))
{
string streamStr = reader.ReadStr("ChartData");
using (MemoryStream stream = Converter.FromString(typeof(Stream), streamStr) as MemoryStream)
{
FChart.Serializer.Reset();
FChart.Serializer.Load(stream);
}
}
}
/// <inheritdoc/>
public override void Deserialize(FRReader reader)
{
base.Deserialize(reader);
if (reader.HasProperty("ImageIndex"))
{
imageIndex = reader.ReadInt("ImageIndex");
if (reader.BlobStore != null && imageIndex != -1)
{
//int saveIndex = FImageIndex;
//Image = ImageHelper.Load(reader.BlobStore.Get(FImageIndex));
//FImageIndex = saveIndex;
SetImageData(reader.BlobStore.Get(imageIndex));
}
}
}
/// <summary>
/// Deserializes nested object properties.
/// </summary>
/// <param name="reader">Reader object.</param>
/// <remarks>
/// <para>Typically the object serializes all properties to the single xml item:</para>
/// <code>
/// <TextObject Name="Text2" Left="18.9" Top="37.8" Width="283.5" Height="28.35"/>
/// </code>
/// <para>Some objects like <see cref="DataBand"/> have child objects that serialized in subitems:</para>
/// <code>
/// <DataBand Name="Data1" Top="163" Width="718.2" Height="18.9">
/// <TextObject Name="Text3" Left="18.9" Top="37.8" Width="283.5" Height="28.35"/>
/// </DataBand>
/// </code>
/// <para>To read such subitems, the <c>DeserializeSubItems</c> method is used. Base
/// implementation reads the child objects. You may override it to read some specific subitems.</para>
/// </remarks>
/// <example>The following code is used to read report's styles:
/// <code>
/// protected override void DeserializeSubItems(FRReader reader)
/// {
/// if (String.Compare(reader.ItemName, "Styles", true) == 0)
/// reader.Read(Styles);
/// else
/// base.DeserializeSubItems(reader);
/// }
/// </code>
/// </example>
protected virtual void DeserializeSubItems(FRReader reader)
{
if (reader.ReadChildren)
{
Base obj = reader.Read() as Base;
if (obj != null)
{
obj.Parent = this;
if (IsAncestor && !obj.IsAncestor)
{
obj.ZOrder = obj.zOrder;
}
}
}
}
