private void OnObjectErased(object sender, _OdDb.ObjectErasedEventArgs e)
{
var obj = e.DBObject;
var ghId = _OdDb.ObjectId.Null;
if (obj is GrasshopperData)
{
ghId = obj.ObjectId;
}
else if (obj is _OdDb.Entity ent)
{
ghId = GrasshopperData.GetGrasshopperData(ent);
}
if (!ghId.IsNull)
{
if (obj.IsErased)
{
_grasshopperData.Remove(obj.ObjectId);
}
else
{
_toUpdate.Add(obj.ObjectId);
}
}
}
public override bool WorldDraw(Drawable drawable, WorldDraw wd)
{
if (drawable is Entity ent)
{
var id = GrasshopperData.GetGrasshopperData(ent);
if (!id.IsNull)
{
var database = id.Database;
var docExt = GhBcConnection.GrasshopperDataExtension.GrasshopperDataManager(database);
var ghDrawable = docExt?.Drawable(id);
if (ghDrawable == null)
{
return(base.WorldDraw(drawable, wd));
}
bool needToDraw = false;
using (var transaction = database.TransactionManager.StartTransaction())
{
var ghData = transaction.GetObject(id, OpenMode.ForRead) as GrasshopperData;
needToDraw = ghData.IsVisible;
transaction.Commit();
}
if (needToDraw)
{
using (var trSt = new TraitsState(wd.SubEntityTraits))
{
wd.Geometry.Draw(ghDrawable);
}
wd.SubEntityTraits.Transparency = new Transparency((byte)GhDataSettings.HostTransparency);
}
}
}
return(base.WorldDraw(drawable, wd));
}
private void OnObjectModified(object sender, _OdDb.ObjectEventArgs e)
{
var objId = e.DBObject.ObjectId;
if (objId.ObjectClass.IsDerivedFrom(_OdRx.RXObject.GetClass(typeof(GrasshopperData))))
{
_toUpdate.Add(objId);
}
else if (e.DBObject is _OdDb.Entity ent)
{
var id = GrasshopperData.GetGrasshopperData(ent);
if (!id.IsNull)
{
_toUpdate.Add(id);
}
}
else if (e.DBObject is _OdDb.BlockTableRecord btr)
{
foreach (_OdDb.ObjectId refId in btr.GetBlockReferenceIds(true, false))
{
using (var blockRef = refId.GetObject(_OdDb.OpenMode.ForRead) as _OdDb.Entity)
{
var id = GrasshopperData.GetGrasshopperData(blockRef);
if (!id.IsNull)
{
_toUpdate.Add(id);
}
}
}
}
}
private void UpdateDrawable(GrasshopperData grasshopperData)
{
if (!grasshopperData.IsVisible)
{
return;
}
var definition = DefinitionManager.Definition(grasshopperData.Definition);
if (definition == null)
{
return;
}
GrasshopperPlayer.Run(definition, grasshopperData, Document);
var newDrawable = new CompoundDrawable
{
Color = GhDataSettings.Color,
ColorSelected = GhDataSettings.Color,
IsRenderMode = GhDataSettings.VisualStyle == GH_PreviewMode.Shaded
};
GrasshopperPreview.GetPreview(definition, newDrawable);
definition.Dispose();
_grasshopperData[grasshopperData.ObjectId] = newDrawable;
}
public bool AddGrasshopperData(GrasshopperData grasshopperData)
{
var objId = grasshopperData.ObjectId;
if (objId.IsNull || _grasshopperData.ContainsKey(objId))
{
return(false);
}
DefinitionManager.Load(grasshopperData.Definition, new string[] { DwgPath });
var definition = DefinitionManager.Definition(grasshopperData.Definition);
if (definition == null)
{
return(false);
}
foreach (var param in GrasshopperPlayer.GetInputParametersValues(definition))
{
if (param.Item2 is Type type)
{
grasshopperData.AddProperty(param.Item1, type);
}
else
{
grasshopperData.AddProperty(param.Item1, param.Item2);
}
}
definition.Dispose();
return(true);
}
public static void Run(GH_Document definition, GrasshopperData ghData, _BcAp.Document bcDoc)
{
bool saveState = GH_Document.EnableSolutions;
GH_Document.EnableSolutions = true;
definition.Enabled = true;
var inputs = GetInputParams(definition);
var hostEntityId = ghData.HostEntity;
foreach (var input in inputs)
{
if (!IsInputName(input.NickName))
{
continue;
}
if (input is Parameters.BcEntity)
{
input.ClearData();
var data = new Types.BcEntity(hostEntityId.ToFsp(), bcDoc.Name);
input.AddVolatileData(new Grasshopper.Kernel.Data.GH_Path(0), 0, data);
data.LoadGeometry(bcDoc);
continue;
}
var prop = ghData.GetProperty(FormatName(input.NickName));
if (prop == null)
{
continue;
}
input.VolatileData.ClearData();
switch (prop)
{
case int intValue:
case double doubleValue:
case bool boolValue:
case string strValue:
input.AddVolatileData(new Grasshopper.Kernel.Data.GH_Path(0), 0, prop);
break;
case _OdGe.Point3d pntValue:
input.AddVolatileData(new Grasshopper.Kernel.Data.GH_Path(0), 0, pntValue.ToRhino());
break;
case _OdGe.Vector3d vecValue:
input.AddVolatileData(new Grasshopper.Kernel.Data.GH_Path(0), 0, vecValue.ToRhino());
break;
}
}
Rhino.RhinoApp.SetFocusToMainWindow();
definition.NewSolution(false, GH_SolutionMode.Silent);
Rhinoceros.Run();
GH_Document.EnableSolutions = saveState;
}
public static void AttachGhData()
{
var editor = Application.DocumentManager.MdiActiveDocument.Editor;
var database = editor.Document.Database;
var selection = editor.GetSelection();
if (selection.Status != PromptStatus.OK)
{
return;
}
string ghDef = null;
var srchPath = Application.GetSystemVariable("SRCHPATH") as string;
var dwgPath = Path.GetDirectoryName(Application.DocumentManager.MdiActiveDocument.Name);
while (true)
{
if (!GH_IO.Serialization.GH_Archive.OpenFileDialog("Select grasshopper defintion", ref ghDef, null) ||
string.IsNullOrEmpty(ghDef))
{
return;
}
var ghDir = Path.GetDirectoryName(ghDef);
if (!srchPath.Contains(ghDir) && dwgPath != ghDir)
{
_WF.MessageBox.Show("Directory should be equal to the current DWG location or be contained in SRCHPATH");
continue;
}
break;
}
if (string.IsNullOrEmpty(ghDef))
{
return;
}
using (var transaction = database.TransactionManager.StartTransaction())
{
for (int i = 0; i < selection.Value.Count; ++i)
{
var ghData = new GrasshopperData(Path.GetFileName(ghDef))
{
IsVisible = true
};
var entity = transaction.GetObject(selection.Value[i].ObjectId, OpenMode.ForWrite) as Entity;
if (GrasshopperData.AttachGrasshopperData(entity, ghData))
{
var docExt = GhBcConnection.GrasshopperDataExtension.GrasshopperDataManager(Application.DocumentManager.MdiActiveDocument, true);
docExt.AddGrasshopperData(ghData);
}
ghData.Dispose();
}
transaction.Commit();
}
}
public GhDataManager(_BcAp.Document doc)
{
Document = doc;
DefinitionManager = new GhDefinitionManager();
DefinitionManager.Reloaded += (s, def) =>
{
using (var transaction = Document.Database.TransactionManager.StartTransaction())
{
foreach (var it in _grasshopperData)
{
var ghDataId = it.Key;
var ghData = transaction.GetObject(ghDataId, _OdDb.OpenMode.ForRead) as GrasshopperData;
if (ghData == null)
{
continue;
}
_toUpdate.Add(ghDataId);
}
}
};
var database = doc.Database;
using (var transaction = database.TransactionManager.StartTransaction())
{
var blockTable = transaction.GetObject(database.BlockTableId, _OdDb.OpenMode.ForRead) as _OdDb.BlockTable;
var searchPath = new string[] { DwgPath };
foreach (var blockId in blockTable)
{
var block = transaction.GetObject(blockId, _OdDb.OpenMode.ForRead) as _OdDb.BlockTableRecord;
foreach (var id in block)
{
var entity = transaction.GetObject(id, _OdDb.OpenMode.ForRead) as _OdDb.Entity;
var ghDataId = GrasshopperData.GetGrasshopperData(entity);
if (ghDataId.IsNull)
{
continue;
}
var ghData = transaction.GetObject(ghDataId, _OdDb.OpenMode.ForRead) as GrasshopperData;
DefinitionManager.Load(ghData.Definition, searchPath);
_toUpdate.Add(ghDataId);
}
}
transaction.Commit();
}
EnableReactors();
}
public static void BakeGhData()
{
var editor = Application.DocumentManager.MdiActiveDocument.Editor;
var selection = editor.GetSelection();
if (selection.Status != PromptStatus.OK)
{
return;
}
var database = editor.Document.Database;
var ghDataToBake = new List <ObjectId>();
using (var transaction = database.TransactionManager.StartTransaction())
{
for (int i = 0; i < selection.Value.Count; ++i)
{
var entity = transaction.GetObject(selection.Value[i].ObjectId, OpenMode.ForRead) as Entity;
var id = GrasshopperData.GetGrasshopperData(entity);
if (!id.IsNull)
{
ghDataToBake.Add(id);
}
}
transaction.Commit();
}
if (ghDataToBake.Count == 0)
{
return;
}
var bakeProperties = new UI.BakeDialog();
if (bakeProperties.ShowDialog() != _WF.DialogResult.OK)
{
return;
}
var docExt = GhBcConnection.GrasshopperDataExtension.GrasshopperDataManager(Application.DocumentManager.MdiActiveDocument, true);
docExt?.Bake(ghDataToBake, bakeProperties);
}
public static void ClearGhData()
{
var editor = Application.DocumentManager.MdiActiveDocument.Editor;
var database = editor.Document.Database;
var selection = editor.GetSelection();
if (selection.Status != PromptStatus.OK)
{
return;
}
using (var transaction = database.TransactionManager.StartTransaction())
{
for (int i = 0; i < selection.Value.Count; ++i)
{
var entity = transaction.GetObject(selection.Value[i].ObjectId, OpenMode.ForWrite) as Entity;
GrasshopperData.RemoveGrasshopperData(entity);
entity?.RecordGraphicsModified(true);
}
transaction.Commit();
}
}
