public override bool Read(GH_IReader reader) { var result = base.Read(reader); m_script = new CsxScript(); m_script.OnError += OnError; var source = reader.GetString("source"); if (File.Exists(source)) { SourceUri = source; m_script.DefineSource(SourceUri); } m_script.OnUpdated += OnUpdated; m_inside = new CsxInputsSide(this, m_script); m_outside = new CsxOutputsSide(this, m_script); if (reader.ChunkExists("m_inconnector")) { m_inside.Read(reader.FindChunk("m_inconnector")); } if (reader.ChunkExists("m_outconnector")) { m_outside.Read(reader.FindChunk("m_outconnector")); } return(result); }
public bool Read(GH_IReader reader) { if (reader.ChunkExists("params")) { GH_IReader val = reader.FindChunk("params"); if (val.ChunkExists("input") && inputs != null) { GH_IReader val2 = val.FindChunk("input"); int num = -1; if (val2.TryGetInt32("count", ref num) && inputs.Count == num) { for (int i = 0; i < num; i++) { if (val2.ChunkExists("p", i)) { inputs[i].Parameter.Read(val2.FindChunk("p", i)); } else if (val2.ChunkExists("param", i)) { inputs[i].Parameter.Read(val2.FindChunk("param", i)); } } } } if (val.ChunkExists("output") && outputs != null) { GH_IReader val3 = val.FindChunk("output"); int num2 = -1; if (val3.TryGetInt32("count", ref num2) && outputs.Count == num2) { for (int j = 0; j < num2; j++) { if (val3.ChunkExists("p", j)) { outputs[j].Parameter.Read(val3.FindChunk("p", j)); } else if (val3.ChunkExists("param", j)) { outputs[j].Parameter.Read(val3.FindChunk("param", j)); } } } } } try { GH_IReader val4 = reader.FindChunk("context"); if (val4 != null) { cxt.Collection.Read(val4); } } catch (Exception ex) { RhinoApp.WriteLine("Component error:" + ex.Message + "\n" + ex.StackTrace); } return(true); }
public override bool Read(GH_IReader reader) { bool flag = true; SetReadState(); flag &= base.Read(reader); string text = null; if (reader.ChunkExists("ActiveUnit")) { text = reader.FindChunk("ActiveUnit").GetString("unitname"); } if (reader.ChunkExists("EvalUnits")) { GH_IReader val = reader.FindChunk("EvalUnits"); int num = -1; if (val.TryGetInt32("count", ref num)) { for (int i = 0; i < num; i++) { if (val.ChunkExists("unit", i)) { GH_IReader val2 = val.FindChunk("unit", i); string @string = val2.GetString("name"); if (text != null) { @string.Equals(text); } evalUnits.GetUnit(@string)?.Read(val2); } } } } if (text != null) { GetUnit(text); SwitchUnit(GetUnit(text), recompute: false, recordEvent: false); } for (int j = 0; j < EvalUnits.Count; j++) { if (!EvalUnits[j].Active) { EvalUnits[j].NewParameterIds(); } } OnComponentLoaded(); return(flag); }
public override bool Read(GH_IReader reader) { GH_IReader gH_IReader = reader.FindChunk("Checkbox", Index); _active = gH_IReader.GetBoolean("Active"); return(true); }
public override bool Read(GH_IReader reader) { Container = null; if (!base.Read(reader)) { return(false); } RemapToTarget = reader.GetBoolean("Remap"); if (RemapToTarget) { Message = "Remap"; } else { Message = string.Empty; } GH_IReader gH_IReader = reader.FindChunk("LocalGraph"); if (gH_IReader != null) { GH_GraphContainer val = new GH_GraphContainer(null); if (!val.Read(gH_IReader)) { return(false); } Container = val; } return(true); }
public override bool Read(GH_IReader reader) { serializedDocumentObjectPivotVectors = reader.FindChunk("SelectedDocumentObjects").Items.Select(x => x.InternalData) .Cast <GH_Point2D>().ToArray(); isSerialized = false; return(base.Read(reader)); }
public static GH_Structure <IGH_Goo> DeserializeGrasshopperData(byte[] array) { GH_LooseChunk val = new GH_LooseChunk("Noah Data"); val.Deserialize_Binary(array); if (val.ItemCount == 0) { return(null); } GH_Structure <IGH_Goo> gH_Structure = new GH_Structure <IGH_Goo>(); GH_IReader val2 = val.FindChunk("Block", 0); bool boolean = val2.GetBoolean("Empty"); if (boolean) { return(null); } GH_IReader val3 = val2.FindChunk("Data"); if (val3 == null) { return(null); } else if (!gH_Structure.Read(val3)) { return(null); } return(gH_Structure); }
public override bool Read(GH_IReader reader) { if (storage.Count > 0) { storage.Clear(); } // Try and read as many "StoredData" chunks as possible. // This approach demands that all these chunks are stored under increasing indices. for (int i = 0; i < int.MaxValue; i++) { var chunk = reader.FindChunk("StoredData", i); // Stop looking once we've run out. if (chunk is null) { break; } var key = chunk.GetString("Key"); var treeChunk = chunk.FindChunk("Tree"); var tree = new GH_Structure <IGH_Goo>(); tree.Read(treeChunk); storage.Add(key, tree); } return(base.Read(reader)); }
public override bool Read(GH_IReader reader) { GH_IReader val = reader.FindChunk("RadioButton", Index); _active = val.GetBoolean("Active"); return(true); }
protected override void SolveInstance(IGH_DataAccess DA) { DA.DisableGapLogic(); string SourceFile = ""; DA.GetData(0, ref SourceFile); if (string.IsNullOrWhiteSpace(SourceFile)) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "No source file has been specified."); return; } if (!File.Exists(SourceFile)) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Source file location doesn't exist: " + SourceFile); return; } byte[] array; try { array = File.ReadAllBytes(SourceFile); } catch (Exception ex) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, ex.Message); return; } GH_LooseChunk val = new GH_LooseChunk("Grasshopper Data"); val.Deserialize_Binary(array); if (val.ItemCount == 0) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Source data file is corrupt."); return; } GH_Structure <IGH_Goo> gH_Structure = new GH_Structure <IGH_Goo>(); GH_IReader val2 = val.FindChunk("Block", 0); if (val2 == null) { base.Params.Output[0].NickName = "?"; DA.SetDataTree(0, gH_Structure); } bool boolean = val2.GetBoolean("Empty"); if (!boolean) { GH_IReader val3 = val2.FindChunk("Data"); if (val3 == null) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Source file is corrupt."); } else if (!gH_Structure.Read(val3)) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Data could not be deserialized."); } } DA.SetDataTree(0, gH_Structure); }
public static IGH_Goo GetGoo(this GH_IReader reader, string itemName) { var dataReader = reader.FindChunk(itemName); var tree = new GH_Structure <IGH_Goo>(); tree.Read(dataReader); return(tree.Branches[0][0]); }
public static GH_Structure <IGH_Goo> GetTree(this GH_IReader reader, string treeName) { var tree = new GH_Structure <IGH_Goo>(); var treeReader = reader.FindChunk(treeName); tree.Read(treeReader); return(tree); }
public static List <IGH_Goo> GetList(this GH_IReader reader, string listName) { var listReader = reader.FindChunk(listName); var tree = new GH_Structure <IGH_Goo>(); tree.Read(listReader); return(tree.Branches[0]); }
public override bool Read(GH_IReader reader) { GH_IReader reader2 = reader.FindChunk("Panel", Index); for (int i = 0; i < _controls.Count; i++) { _controls[i].Read(reader2); } return(base.Read(reader)); }
private static GH_ISerializable ReadGH_ISerializable(GH_IReader reader) { var valueTypeString = reader.GetString("TypeString"); var valueAssemblyString = reader.GetString("AssemblyString"); var valueInstance = (GH_ISerializable)Activator.CreateInstance(valueAssemblyString, valueTypeString).Unwrap(); var instanceReader = reader.FindChunk("Data"); valueInstance.Read(instanceReader); return(valueInstance); }
public static IDictionary <T1, T2> GetDictionary <T1, T2>( this GH_IReader reader, string itemName, Func <GH_IReader, string, int, T1> keyGetter, Func <GH_IReader, string, int, T2> valueGetter ) { var dataReader = reader.FindChunk(itemName); return(ReadDictionary(dataReader, keyGetter, valueGetter)); }
public override bool Read(GH_IReader reader) { GH_IReader val = reader.FindChunk("MenuDropDown", Index); try { current_value = val.GetInt32("ActiveItemIndex"); } catch { current_value = default_item_index; } return(true); }
public override bool Read(GH_IReader reader) { GH_IReader gH_IReader = reader.FindChunk("Slider", Index); minValue = gH_IReader.GetDouble("MinValue"); maxValue = gH_IReader.GetDouble("MaxValue"); currentValue = gH_IReader.GetDouble("CurrentValue"); if (!gH_IReader.TryGetInt32("NumDecimals", ref numDecimals)) { numDecimals = 2; } FixValues(); return(true); }
public override bool Read(GH_IReader reader) { //IL_0078: Unknown result type (might be due to invalid IL or missing references) //IL_007e: Expected O, but got Unknown string text = "RadioButtonGroup"; GH_IReader val = reader.FindChunk(text, Index); if (val == null) { List <GH_IChunk> chunks = ((GH_IChunk)reader).Chunks; GH_IChunk val2 = null; foreach (GH_IChunk chunk in ((GH_IChunk)reader).Chunks) { if (chunk.Name.Equals(text)) { val2 = chunk; break; } } if (val2 == null) { throw new ArgumentException("fail"); } if (chunks.Count != 1) { throw new ArgumentException("RadioButtonGroup could not be loaded"); } val = (GH_IReader)(GH_Chunk)val2; } int count = _buttons.Count; int @int = val.GetInt32("Count"); GH_IReader val3 = val.FindChunk("Active"); actives.Clear(); for (int i = 0; i < count; i++) { bool boolean = val3.GetBoolean("button", i); _buttons[i].Active = boolean; if (boolean) { actives.Add(_buttons[i]); } } return(true); }
public override bool Read(GH_IReader reader) { int mode = 1; reader.TryGetInt32("UIMode", ref mode); reader.TryGetInt32("ListMode", ref mode); this.ListMode = (GH_ValueListMode)mode; int count = reader.GetInt32("ListCount"); int cache = 0; reader.TryGetInt32("CacheCount", ref cache); this.m_userItems.Clear(); int arg_52_0 = 0; int num = count - 1; for (int i = arg_52_0; i <= num; i++) { GH_IReader chunk = reader.FindChunk("ListItem", i); if (chunk == null) { reader.AddMessage("Missing chunk for List Value: " + i.ToString(), GH_Message_Type.error); } else { string itemName = chunk.GetString("Name"); string itemExpression = chunk.GetString("Expression"); bool itemSelected = false; chunk.TryGetBoolean("Selected", ref itemSelected); Type t = JsonConvert.DeserializeObject <Type>(chunk.GetString("Type")); object deserializedExpression = JsonConvert.DeserializeObject(itemExpression, t); GuanacoListItem item = new GuanacoListItem(itemName, deserializedExpression); item.Selected = itemSelected; this.m_userItems.Add(item); } } if (reader.ItemExists("ListIndex")) { int idx = reader.GetInt32("ListIndex"); if (idx >= 0 && idx < this.m_userItems.Count) { this.m_userItems[idx].Selected = true; } } return(base.Read(reader)); }
/// <summary> /// Read all required data for deserialization from an IO archive. /// </summary> /// <param name="reader">Object to read with.</param> /// <returns> /// True on success, false on failure. /// </returns> public override bool Read(GH_IReader reader) { // set up a "shadow" state set of only basic data types // check out that wackadoodle data type - it's a Dictionary<string, Dictionary<Tuple<Guid, int>, object>> :-p Dictionary <string, Dictionary <Tuple <Guid, int>, object> > stateSet = new Dictionary <string, Dictionary <Tuple <Guid, int>, object> >(); GH_IReader stateSetChunk = reader.FindChunk("stateSetChunk"); int stateCount = stateSetChunk.GetInt32("StateCount"); //for all the states in the archive for (int i = 0; i < stateCount; i++) { Dictionary <Tuple <Guid, int>, object> state = new Dictionary <Tuple <Guid, int>, object>(); GH_IReader stateChunk = stateSetChunk.FindChunk("State", i); string stateName = stateChunk.GetString("stateName"); int itemCount = stateChunk.GetInt32("itemCount"); //for all the elements in the state for (int j = 0; j < itemCount; j++) { GH_IReader stateItemChunk = stateChunk.FindChunk("stateItem", j); Guid elementID = new Guid(stateItemChunk.GetString("ElementID")); int index = stateItemChunk.GetInt32("ElementIndex"); string elementValue = stateItemChunk.GetString("ElementValue"); string elementValueType = stateItemChunk.GetString("ElementValueType"); Tuple <Guid, int> goo = new Tuple <Guid, int>(elementID, index); object value = getValue(elementValue, elementValueType); state.Add(goo, value); } if (stateSet.ContainsKey(stateName)) { stateSet[stateName] = state; } else { stateSet.Add(stateName, state); } } savedShadowStates = stateSet; return(base.Read(reader)); }
// // Writing and Reading. // Any methods to save custom properties apart from those of the original // component should be defined here. // ______________________________________________ public override bool Read(GH_IReader reader) { try { GH_IReader reader2 = reader.FindChunk("Hoopsnake_Data"); if (reader2 != null) { dataLimit = Int32.MaxValue;// FIX THAT!!! //int.Parse(reader2.GetInt32("dataLimit").ToString()); resetCounterOnLoop = reader2.GetBoolean("resetCounter"); updateView = reader2.GetBoolean("updateView"); autoUpdate = reader2.GetBoolean("autoUpdate"); int newDelay = 0; reader2.TryGetInt32("delay", ref newDelay); } } catch {} // In the end, call the reader of the base component to load inherited fields. return(base.Read(reader)); }
public bool Read(GH_IReader reader) { GH_IReader val = reader.FindChunk("Collection"); if (val == null) { RhinoApp.WriteLine("Invalid menu collection"); return(false); } for (int i = 0; i < _menus.Count; i++) { GH_IReader val2 = val.FindChunk("Menu", i); if (val2 == null) { return(false); } _menus[i].Read(val2); } return(true); }
public override bool Read(GH_IReader reader) { try { base.Read(reader); var count = reader.GetInt32("GridCount"); var data = new GH_Structure <GH_VoxelGrid>(); for (var i = 0; i < count; i++) { var currentGrid = reader.FindChunk("Grid", i); var gridString = currentGrid.GetString("Data"); var pathString = currentGrid.GetString("Path"); var path = new GH_Path(); path.FromString(pathString); var output = ByteHelper.ToVoxelGrid(ByteHelper.Decompress(ByteHelper.StringToByteArray(gridString))); data.Append(new GH_VoxelGrid(output), path); } SetPersistentData(data); return(true); } catch (Exception e) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, e + " " + e.StackTrace); return(true); } }
public override bool Read(GH_IReader reader) { int num1 = 1; reader.TryGetInt32("UIMode", ref num1); reader.TryGetInt32("ListMode", ref num1); ListMode = (GH_ValueListMode)num1; int int32 = reader.GetInt32("ListCount"); int num2 = 0; reader.TryGetInt32("CacheCount", ref num2); m_userItems.Clear(); int num3 = 0; int num4 = int32 - 1; for (int index = num3; index <= num4; ++index) { GH_IReader chunk = reader.FindChunk("ListItem", index); if (chunk == null) { reader.AddMessage("Missing chunk for List Value: " + index.ToString(), GH_Message_Type.error); } else { string name = chunk.GetString("Name"); string expression = chunk.GetString("Expression"); bool flag = false; chunk.TryGetBoolean("Selected", ref flag); m_userItems.Add(new GH_ValueListItem(name, expression) { Selected = flag }); } } return(base.Read(reader)); }
public static IEnumerable <T> GetEnumerable <T>(this GH_IReader reader, string itemName, Func <GH_IReader, string, int, T> getter) { var dataReader = reader.FindChunk(itemName); return(ReadEnumerable <T>(dataReader, getter)); }
public static GeometryBase GetGeometryBase(this GH_IReader reader, string itemName) { var dataReader = reader.FindChunk(itemName); return(ReadGeometryBase(dataReader)); }
// // Writing and Reading. // Any methods to save custom properties apart from those of the original // component should be defined here. // ______________________________________________ public override bool Read(GH_IReader reader) { try { GH_IReader reader2 = reader.FindChunk("Hoopsnake_Data"); if (reader2 != null) { dataLimit = Int32.MaxValue;// FIX THAT!!! //int.Parse(reader2.GetInt32("dataLimit").ToString()); resetCounterOnLoop = reader2.GetBoolean("resetCounter"); updateView = reader2.GetBoolean("updateView"); autoUpdate = reader2.GetBoolean("autoUpdate"); int newDelay = 0; reader2.TryGetInt32("delay", ref newDelay); } } catch {} // In the end, call the reader of the base component to load inherited fields. return base.Read(reader); }
public static GH_ISerializable GetGH_ISerializable(this GH_IReader reader, string itemName) { var dataReader = reader.FindChunk(itemName); return(ReadGH_ISerializable(dataReader)); }