Exemplo n.º 1
0
        public override bool Write(GH_IWriter writer)
        {
            var result = base.Write(writer);

            writer.SetBoolean(HistoryKey, IncludeHistory);
            return(result);
        }
Exemplo n.º 2
0
 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));
 }
Exemplo n.º 3
0
        public override bool Write(GH_IWriter writer)
        {
            writer.SetBoolean("Horizontal", IsHorizontal);
            writer.SetBoolean("Extents", IsFill);

            return(base.Write(writer));
        }
Exemplo n.º 4
0
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        /// <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));
        }
Exemplo n.º 5
0
        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));
        }
Exemplo n.º 6
0
        /*
         * 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);
            }
        }
Exemplo n.º 7
0
        public override bool Write(GH_IWriter writer)
        {
            writer.SetInt32("FilterMode", FilterMode);
            writer.SetBoolean("Optimize", OptimizeCurve);

            return(base.Write(writer));
        }
Exemplo n.º 8
0
        public override bool Write(GH_IWriter writer)
        {
            var result = base.Write(writer);

            writer.SetInt32("ScriptParamAccess", (int)Access);
            return(result);
        }
Exemplo n.º 9
0
        public override bool Write(GH_IWriter writer)
        {
            writer.SetString("Wave", Wave.ToString());
            writer.SetString("Profile", Profile.ToString());

            return(base.Write(writer));
        }
Exemplo n.º 10
0
        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));
        }
Exemplo n.º 11
0
 public override bool Write(GH_IWriter writer)
 {
     writer.SetDouble("e", e);
     writer.SetDouble("t0", t0);
     writer.SetDouble("t1", t1);
     return(true);
 }
Exemplo n.º 12
0
 public override bool Write(GH_IWriter writer)
 {
     writer.SetBoolean("PolyE1", PolygonA);
     writer.SetBoolean("PolyE2", PolygonB);
     writer.SetBoolean("PolyE3", PolygonC);
     return(base.Write(writer));
 }
Exemplo n.º 13
0
        /*
         * 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);
        }
Exemplo n.º 14
0
        /// <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));
        }
Exemplo n.º 15
0
 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));
 }
Exemplo n.º 17
0
 public override bool Write(GH_IWriter writer)
 {
     writer.SetBoolean("Abs1", Abs1);
     writer.SetBoolean("Abs2", Abs2);
     writer.SetBoolean("Abs3", Abs3);
     return(base.Write(writer));
 }
Exemplo n.º 18
0
        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;
            }
        }
Exemplo n.º 19
0
 public override bool Write(GH_IWriter writer)
 {
     writer.SetBoolean("PlyFromWidth1", Flag);
     writer.SetBoolean("PlyFromWidth2", Flag2);
     writer.SetBoolean("PlyFromWidth3", Flag3);
     return(base.Write(writer));
 }
Exemplo n.º 20
0
 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));
 }
Exemplo n.º 21
0
 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));
 }
Exemplo n.º 23
0
    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);
    }
Exemplo n.º 24
0
 //      Serialization
 public override bool Write(GH_IWriter writer)
 {
     writer.SetBoolean("isInstruction", isInstruction);
     writer.SetBoolean("colorize", colorize);
     writer.SetBoolean("angleApproach", angleApproach);
     return(base.Write(writer));
 }
Exemplo n.º 25
0
 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));
 }
Exemplo n.º 27
0
 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));
 }
Exemplo n.º 28
0
 public override bool Write(GH_IWriter writer)
 {
     writer.SetBoolean("IntList", IntList);
     writer.SetBoolean("BoolList", BoolList);
     writer.SetBoolean("IntervalList", IntervalList);
     return(base.Write(writer));
 }
Exemplo n.º 29
0
        public override bool Write(GH_IWriter writer)
        {
            writer.SetInt32("Pattern", GradientType);
            writer.SetInt32("Space", GradientSpace);

            return(base.Write(writer));
        }
Exemplo n.º 30
0
        public override bool Write(GH_IWriter writer)
        {
            writer.SetInt32("Modes", (int)modes);
            writer.SetInt32("steps", this.steps);

            return(base.Write(writer));
        }
Exemplo n.º 31
0
 //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);
 }
Exemplo n.º 32
0
 public override bool Write(GH_IWriter writer)
 {
     writer.SetBoolean("IsCartesian", isCartesian);
     return base.Write(writer);
 }
Exemplo n.º 33
0
 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);
 }
Exemplo n.º 34
0
        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);
        }