public override bool Write(GH_IWriter writer) { var result = base.Write(writer); writer.SetBoolean(HistoryKey, IncludeHistory); return(result); }
public override bool Write(GH_IWriter writer) { writer.SetBoolean("Display Faces", this.faces); writer.SetBoolean("Display Edges", this.edgesE); writer.SetBoolean("Display Edge Faces", this.edgesF); return(base.Write(writer)); }
public override bool Write(GH_IWriter writer) { writer.SetBoolean("Horizontal", IsHorizontal); writer.SetBoolean("Extents", IsFill); return(base.Write(writer)); }
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ /// <summary> /// Adds to the default serialization method to save the current child status so it persists on copy/paste and save/reopen. /// </summary> public override bool Write(GH_IWriter writer) { writer.SetInt32("mIndex", mIndex); writer.SetInt32("tIndex", tIndex); return(base.Write(writer)); }
public bool Write(GH_IWriter writer) { writer.SetString("name", Name); GH_IWriter val = writer.CreateChunk("params"); GH_IWriter val2 = val.CreateChunk("input"); val2.SetInt32("index", 0); val2.SetInt32("count", Inputs.Count); for (int i = 0; i < inputs.Count; i++) { if (inputs[i].Parameter.Attributes != null) { GH_IWriter val3 = val2.CreateChunk("p", i); inputs[i].Parameter.Write(val3); } } GH_IWriter val4 = val.CreateChunk("output"); val4.SetInt32("index", 0); val4.SetInt32("count", Outputs.Count); for (int j = 0; j < outputs.Count; j++) { if (outputs[j].Parameter.Attributes != null) { GH_IWriter val5 = val4.CreateChunk("p", j); outputs[j].Parameter.Write(val5); } } GH_IWriter writer2 = writer.CreateChunk("context"); return(cxt.Collection.Write(writer2)); }
/* * public void Dispose() * { * foreach (Mesh m in this._meshCache) * { * m.Dispose(); * } * }*/ public override bool Write(GH_IWriter writer) { base.Write(writer); try { writer.RemoveChunk("PersistentData"); writer.SetInt32("GridCount", PersistentData.DataCount); var total = 0; for (var i = 0; i < PersistentData.Branches.Count; i++) { var path = PersistentData.Paths[i]; foreach (var ghvg in PersistentData.Branches[i]) { var currentGrid = writer.CreateChunk("Grid", total); currentGrid.SetString("Data", ByteHelper.ByteToHex(ByteHelper.Compress(ByteHelper.ToByte(ghvg.Value)))); currentGrid.SetString("Path", path.ToString()); total++; } } return(true); } catch (Exception e) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, e + " " + e.StackTrace); return(true); } }
public override bool Write(GH_IWriter writer) { writer.SetInt32("FilterMode", FilterMode); writer.SetBoolean("Optimize", OptimizeCurve); return(base.Write(writer)); }
public override bool Write(GH_IWriter writer) { var result = base.Write(writer); writer.SetInt32("ScriptParamAccess", (int)Access); return(result); }
public override bool Write(GH_IWriter writer) { writer.SetString("Wave", Wave.ToString()); writer.SetString("Profile", Profile.ToString()); return(base.Write(writer)); }
public override bool Write(GH_IWriter writer) { writer.SetInt32("FPSIndex", FPSindex); writer.SetInt32("SizeWidth", PictWidth); writer.SetInt32("SizeHeight", PictHeight); writer.SetInt32("SizeIndex", Sizeindex); writer.SetInt32("TypeIndex", Typeindex); writer.SetBoolean("Duration", Duration); writer.SetBoolean("Remap", Remap); writer.SetDouble("TimeInFrame", TimeInFrame); writer.SetDouble("DelayLog", DelayLog); writer.SetBoolean("Save", Save); writer.SetDouble("SliderMul", SliderMultiple); writer.SetDouble("ViewportReduce", ViewportReduce); writer.SetBoolean("ShowLabel", ShowLabel); writer.SetDouble("LabelSize", LabelSize); writer.SetBoolean("ShowFrame", ShowFrame); writer.SetBoolean("ShowTime", ShowTime); writer.SetBoolean("ShowPercent", ShowPercent); writer.SetBoolean("ShowRemain", ShowRemain); writer.SetBoolean("ShowGraph", ShowGraph); writer.SetBoolean("ShowGraphEvent", ShowGraphOnEvent); return(base.Write(writer)); }
public override bool Write(GH_IWriter writer) { writer.SetDouble("e", e); writer.SetDouble("t0", t0); writer.SetDouble("t1", t1); return(true); }
public override bool Write(GH_IWriter writer) { writer.SetBoolean("PolyE1", PolygonA); writer.SetBoolean("PolyE2", PolygonB); writer.SetBoolean("PolyE3", PolygonC); return(base.Write(writer)); }
/* * public void DrawViewportMeshes(GH_PreviewMeshArgs args) * { * if (DisplayMesh != null) * args.Pipeline.DrawMeshShaded(DisplayMesh, args.Material); * } * * public void DrawViewportWires(GH_PreviewWireArgs args) * { * if (DisplayMesh != null) * args.Pipeline.DrawMeshWires(DisplayMesh, args.Color); * } */ #region Serialization public override bool Write(GH_IWriter writer) { if (Value == null) { return(false); } byte[] centrelineBytes = GH_Convert.CommonObjectToByteArray(Value.Centreline); writer.SetByteArray("guide", centrelineBytes); //writer.SetInt32("num_frames", Value.Frames.Count); //for (int i = 0; i < Value.Frames.Count; ++i) //{ // Plane p = Value.Frames[i].Item2; // // writer.SetPlane("frames", i, new GH_IO.Types.GH_Plane( // p.OriginX, p.OriginY, p.OriginZ, p.XAxis.X, p.XAxis.Y, p.XAxis.Z, p.YAxis.X, p.YAxis.Y, p.YAxis.Z)); //} writer.SetInt32("lcx", Value.Data.NumWidth); writer.SetInt32("lcy", Value.Data.NumHeight); writer.SetDouble("lsx", Value.Data.LamWidth); writer.SetDouble("lsy", Value.Data.LamHeight); writer.SetInt32("interpolation", (int)Value.Data.InterpolationType); writer.SetInt32("samples", Value.Data.Samples); return(true); }
/// <summary> /// Write all required data for deserialization to an IO archive. /// </summary> /// <param name="writer">Object to write with.</param> /// <returns> /// True on success, false on failure. /// </returns> public override bool Write(GH_IWriter writer) { //serialize the states GH_IWriter stateSetChunk = writer.CreateChunk("stateSetChunk"); stateSetChunk.SetInt32("StateCount", savedStates.states.Count); int i = 0; //the state //for each state in saved states foreach (KeyValuePair <string, State> statePair in savedStates.states) { string stateName = statePair.Key; GH_IWriter StateChunk = stateSetChunk.CreateChunk("State", i); StateChunk.SetString("stateName", stateName); State state = statePair.Value; StateChunk.SetInt32("itemCount", state.stateDict.Count); int j = 0; //Custom serialization logic //for each element in the state foreach (KeyValuePair <UIElement_Goo, object> stateItem in state.stateDict) { //get element and value UIElement_Goo element = stateItem.Key; object value = stateItem.Value; GH_IWriter stateItemChunk = StateChunk.CreateChunk("stateItem", j); //this info is used to retrieve the dynamic UI element on reserialization, by grabbing the component with matching instance guid //and getting the output item at the matching index. stateItemChunk.SetString("ElementID", element.instanceGuid.ToString()); stateItemChunk.SetInt32("ElementIndex", element.index); string stringValue = value.ToString(); string typeString = value.GetType().ToString(); //special case for lists of bool - all other element "states" are single items. This only applies to a checklist object. if (value is List <bool> ) { typeString = "LIST OF BOOL"; stringValue = HUI_Util.stringFromBools((List <bool>)value); } if (value is List <string> ) { typeString = "LIST OF STRING"; stringValue = HUI_Util.stringFromStrings((List <string>)value); } //store the value and a hint as to its type stateItemChunk.SetString("ElementValue", stringValue); stateItemChunk.SetString("ElementValueType", typeString); j++; //counting up elements in state } i++; //counting up states } return(base.Write(writer)); }
public new bool Write(GH_IWriter writer) { writer.SetDrawingBitmap("Image", this.Value); writer.SetString("ReportPart", this.ReportPart); writer.SetString("RefTag", this._refTag); return(true); }
/// <summary> /// Add our own fields. Needed for (de)serialization of the variable input parameters. /// </summary> /// <param name="writer"> Provides access to a subset of GH_Chunk methods used for writing archives. </param> /// <returns> True on success, false on failure. </returns> public override bool Write(GH_IWriter writer) { writer.SetBoolean("Set Mass", SetMass); writer.SetBoolean("Set Center of Gravity", SetCenterOfGravity); writer.SetBoolean("Set Moment of Inertia", SetMomentOfInertia); return(base.Write(writer)); }
public override bool Write(GH_IWriter writer) { writer.SetBoolean("Abs1", Abs1); writer.SetBoolean("Abs2", Abs2); writer.SetBoolean("Abs3", Abs3); return(base.Write(writer)); }
public override bool Write(GH_IWriter writer) { staticData.PrepareWrite(activeUnit); bool result = base.Write(writer); staticData.RestoreWrite(activeUnit); if (activeUnit != null) { writer.CreateChunk("ActiveUnit").SetString("unitname", activeUnit.Name); } try { GH_IWriter val = writer.CreateChunk("EvalUnits"); val.SetInt32("count", evalUnits.Units.Count); for (int i = 0; i < evalUnits.Units.Count; i++) { EvaluationUnit evaluationUnit = evalUnits.Units[i]; GH_IWriter writer2 = val.CreateChunk("unit", i); evaluationUnit.Write(writer2); } return(result); } catch (Exception ex) { RhinoApp.WriteLine(ex.Message + "\n" + ex.StackTrace); throw ex; } }
public override bool Write(GH_IWriter writer) { writer.SetBoolean("PlyFromWidth1", Flag); writer.SetBoolean("PlyFromWidth2", Flag2); writer.SetBoolean("PlyFromWidth3", Flag3); return(base.Write(writer)); }
public override bool Write(GH_IWriter writer) { writer.SetString("Coloring", Coloring.ToString()); writer.SetString("Metric", Metric.ToString()); writer.SetString("Feature", Feature.ToString()); return(base.Write(writer)); }
public override bool Write(GH_IWriter writer) { try { if (Client != null) { using (var ms = new MemoryStream()) { var formatter = new BinaryFormatter(); formatter.Serialize(ms, Client); var arr = ms.ToArray(); var arrr = arr; writer.SetByteArray("speckleclient", ms.ToArray()); writer.SetBoolean("remotecontroller", EnableRemoteControl); writer.SetBoolean("manualmode", ManualMode); writer.SetBoolean("DebouncingDisabled", DebouncingDisabled); } } } catch (Exception err) { throw err; } return(base.Write(writer)); }
/// <summary> /// Add our own fields. Needed for (de)serialization of the variable input parameters. /// </summary> /// <param name="writer"> Provides access to a subset of GH_Chunk methods used for writing archives. </param> /// <returns> True on success, false on failure. </returns> public override bool Write(GH_IWriter writer) { writer.SetBoolean("Override Robot Tool", OverrideRobotTool); writer.SetBoolean("Override Work Object", OverrideWorkObject); writer.SetBoolean("Set Digital Output", SetDigitalOutput); return(base.Write(writer)); }
public override bool Write(GH_IWriter writer) { var nn = new BinaryFormatter(); writer.SetInt32("FunctionCount", this.Value.NeuronFunctions.Count); for (int i = 0, loopTo = this.Value.NeuronFunctions.Count - 1; i <= loopTo; i += 1) { using (var mstr = new MemoryStream()) { nn.Serialize(mstr, this.Value.NeuronFunctions(i)); writer.SetByteArray("Function_" + i, mstr.ToArray()); } } using (var mstr = new MemoryStream()) { Owl.Core.IO.WriteTensors(mstr, this.Value.Biases); writer.SetByteArray("Biases", mstr.ToArray()); } using (var mstr = new MemoryStream()) { Owl.Core.IO.WriteTensors(mstr, this.Value.Weights); writer.SetByteArray("Weights", mstr.ToArray()); } return(true); }
// Serialization public override bool Write(GH_IWriter writer) { writer.SetBoolean("isInstruction", isInstruction); writer.SetBoolean("colorize", colorize); writer.SetBoolean("angleApproach", angleApproach); return(base.Write(writer)); }
public override bool Write(GH_IWriter writer) { writer.SetBoolean("_VectorX", _VectorX); writer.SetBoolean("_VectorY", _VectorY); writer.SetBoolean("_VectorZ", _VectorZ); return(base.Write(writer)); }
//Write public override bool Write(GH_IWriter writer) { writer.SetDouble("scale", this.Scale); writer.SetBoolean("DisableClickable", this.DisableClickable); writer.SetBoolean("SaveImgWithCoords", this.ifSaveThis); return(base.Write(writer)); }
public override bool Write(GH_IWriter writer) { //writer.SetString( "selectedAccount", SNJ.JsonConvert.SerializeObject( Selected ) ); writer.SetString("restapi", Selected.RestApi); writer.SetString("email", Selected.Email); return(base.Write(writer)); }
public override bool Write(GH_IWriter writer) { writer.SetBoolean("IntList", IntList); writer.SetBoolean("BoolList", BoolList); writer.SetBoolean("IntervalList", IntervalList); return(base.Write(writer)); }
public override bool Write(GH_IWriter writer) { writer.SetInt32("Pattern", GradientType); writer.SetInt32("Space", GradientSpace); return(base.Write(writer)); }
public override bool Write(GH_IWriter writer) { writer.SetInt32("Modes", (int)modes); writer.SetInt32("steps", this.steps); return(base.Write(writer)); }
//write and read allow the settings to persist through document save and component copy/paste. public override bool Write(GH_IWriter writer) { writer.SetBoolean("createNewSpreadsheets", createNewSpreadsheets); return base.Write(writer); }
public override bool Write(GH_IWriter writer) { writer.SetBoolean("IsCartesian", isCartesian); return base.Write(writer); }
public override bool Write(GH_IWriter writer) { try { GH_IWriter writer2 = writer.CreateChunk("Hoopsnake_Data"); writer2.SetInt32("dataLimit", dataLimit); writer2.SetBoolean("resetCounter", resetCounterOnLoop); writer2.SetBoolean("updateView", updateView); writer2.SetBoolean("autoUpdate", autoUpdate); writer2.SetInt32("delay", delay); } catch {} return base.Write(writer); }
public override bool Write(GH_IWriter writer) { if (m_settings != null && m_settings.Length > 0) { writer.SetInt32("StringCount", m_settings.Length); for (int i = 0; i < m_settings.Length; i++) { writer.SetString("String", i, m_settings[i]); } } return base.Write(writer); }