protected override bool Write(Rhino.FileIO.BinaryArchiveWriter archive)
{
var dict = new Rhino.Collections.ArchivableDictionary(20171031, "Values");
int i = 0;
foreach (GeometrySegment geoSeg in GeometrySegments)
{
dict.Set("geoSeg" + i, i);
dict.Set("gsBrep" + i, geoSeg.BrepGeometry);
if (geoSeg.Material.GetType() == typeof(ConcreteMaterial))
{
ConcreteMaterial material = geoSeg.Material as ConcreteMaterial;
dict.Set("gsMaterial" + i, "Concrete");
dict.Set("gsMaterialStrength" + i, material.StrenghtClass);
}
else if (geoSeg.Material.GetType() == typeof(SteelMaterial))
{
SteelMaterial material = geoSeg.Material as SteelMaterial;
dict.Set("gsMaterial" + i, "Steel");
dict.Set("gsMaterialName" + i, material.Name);
}
i++;
}
archive.WriteDictionary(dict);
return(true);
}
//If any ON_BinaryArchive::Write*() functions return false than you should
//immediately return false otherwise return true if all data was written
//successfully. Returning false will cause Rhino to stop writing this document.
protected override void WriteDocument(Rhino.RhinoDoc doc, Rhino.FileIO.BinaryArchiveWriter archive, Rhino.FileIO.FileWriteOptions options)
{
//This function is called because ShouldCallWriteDocument returned True.
//Write your plug-in data to the document
string date_string = System.DateTime.Now.ToShortDateString();
string time_string = System.DateTime.Now.ToShortTimeString();
//It is a good idea to always start with a version number
//so you can modify your document read/write code in the future
archive.Write3dmChunkVersion(1, 0);
archive.WriteString(date_string);
archive.WriteString(time_string);
UI.Pach_Source_Object S_command = Pach_Source_Object.Instance;
UI.Pach_Receiver_Object R_command = Pach_Receiver_Object.Instance;
foreach (System.Guid ID in SourceConduit.Instance.UUID)
{
System.Guid N_ID = new System.Guid(ID.ToString());
archive.WriteGuid(N_ID);
archive.WriteString("Source");
}
foreach (System.Guid ID in ReceiverConduit.Instance.UUID)
{
System.Guid N_ID = new System.Guid(ID.ToString());
archive.WriteGuid(N_ID);
archive.WriteString("Receiver");
}
}
protected override bool Write(Rhino.FileIO.BinaryArchiveWriter archive)
{
Rhino.Collections.ArchivableDictionary dict = new Rhino.Collections.ArchivableDictionary(1, "IgnorantCustomClass");
base.WriteHotLoadData(dict);
return(true);
}
protected override bool Write(Rhino.FileIO.BinaryArchiveWriter archive)
{
archive.Write3dmChunkVersion(1, 0);
var dic = Serialize();
archive.WriteDictionary(dic);
return(!archive.WriteErrorOccured);
}
protected override bool Write(Rhino.FileIO.BinaryArchiveWriter archive)
{
Rhino.Collections.ArchivableDictionary dict = new Rhino.Collections.ArchivableDictionary(1, "CustomDataClass");
base.WriteHotLoadData(dict);
dict.Set("alpha", alpha);
dict.Set("beta", beta);
dict.Set("classA", JsonConvert.SerializeObject(classA, Formatting.Indented));
dict.Set("classB", JsonConvert.SerializeObject(classB, Formatting.Indented));
dict.Set("classC", JsonConvert.SerializeObject(classC, Formatting.Indented));
dict.Set("classD", JsonConvert.SerializeObject(classD, Formatting.Indented));
dict.Set("classE", JsonConvert.SerializeObject(classE, Formatting.Indented));
archive.WriteDictionary(dict);
return(true);
}
protected override bool Write(Rhino.FileIO.BinaryArchiveWriter archive)
{
// you can implement File IO however you want... but the dictionary class makes
// issues like versioning in the 3dm file a bit easier. If you didn't want to use
// the dictionary for writing, your code would look something like.
//
// archive.Write3dmChunkVersion(1, 0);
// archive.WriteInt(IntegerData);
// archive.WriteString(StringData);
var dict = new Rhino.Collections.ArchivableDictionary(1, "MyCustomData");
dict.Set("IntegerData", IntegerData);
dict.Set("StringData", StringData);
archive.WriteDictionary(dict);
return(true);
}
protected override bool Write(Rhino.FileIO.BinaryArchiveWriter archive)
{
var dict = new Rhino.Collections.ArchivableDictionary(20181023, "Values");
dict.Set("baseBrep", BaseBrep);
dict.Set("Id", Id);
if (OwnerBeam != null)
{
dict.Set("BeamId", OwnerBeam.Id);
}
else
{
dict.Set("BeamId", -1);
}
dict.Set("NoBaseCurves", BaseCurves.Count);
for (int i = 0; i < BaseCurves.Count; i++)
{
dict.Set("BaseCurve" + i, BaseCurves[i]);
}
if (Material.GetType() == typeof(ConcreteMaterial))
{
ConcreteMaterial material = Material as ConcreteMaterial;
dict.Set("Material", "Concrete");
dict.Set("MaterialStrength", material.StrengthClass);
}
else if (Material.GetType() == typeof(SteelMaterial))
{
SteelMaterial material = Material as SteelMaterial;
dict.Set("Material", "Steel");
dict.Set("MaterialName", material.StrengthClass);
}
archive.WriteDictionary(dict);
return(true);
}
protected override bool Write(Rhino.FileIO.BinaryArchiveWriter archive)
{
var dict = new Rhino.Collections.ArchivableDictionary(20171031, "Values");
dict.Set("Point", BasePoint);
dict.Set("OutLine", OutLine);
dict.Set("Diameter", _diameter);
if (Material is SteelMaterial material)
{
dict.Set("MaterialName", material.Name);
}
else
{
dict.Set("MaterialName", "B500B");
RhinoApp.WriteLine("No material was assigned to reinforcement.");
}
archive.WriteDictionary(dict);
return(true);
}
private static int InternalWriteDocument(int plugin_serial_number, int doc_id, IntPtr pBinaryArchive, IntPtr pWriteOptions)
{
int rc = 1; //TRUE
PlugIn p = LookUpBySerialNumber(plugin_serial_number);
RhinoDoc doc = RhinoDoc.FromId(doc_id);
if (p != null && doc != null && pBinaryArchive != IntPtr.Zero && pWriteOptions != IntPtr.Zero)
{
Rhino.FileIO.BinaryArchiveWriter writer = new Rhino.FileIO.BinaryArchiveWriter(pBinaryArchive);
Rhino.FileIO.FileWriteOptions wo = new Rhino.FileIO.FileWriteOptions(pWriteOptions);
try
{
p.WriteDocument(doc, writer, wo);
rc = writer.WriteErrorOccured ? 0 : 1;
}
catch (Exception ex)
{
HostUtils.ExceptionReport(ex);
rc = 0; //FALSE
}
// in case someone tries to hold on to instances of these classes
writer.ClearPointer();
wo.Dispose();
}
return rc;
}
protected override void WriteDocument(RhinoDoc doc, Rhino.FileIO.BinaryArchiveWriter archive, Rhino.FileIO.FileWriteOptions options)
{
archive.WriteDictionary(m_dict);
}
protected override bool Write(Rhino.FileIO.BinaryArchiveWriter archive)
{
archive.Write3dmChunkVersion(1, 0);
archive.WriteString(Notes);
return(!archive.WriteErrorOccured);
}
/// <summary>Writes the content of this data to a stream archive.</summary>
/// <param name="archive">An archive.</param>
/// <returns>true if the data was successfully written. The default implementation always returns false.</returns>
protected virtual bool Write(Rhino.FileIO.BinaryArchiveWriter archive)
{
return(false);
}
