private List <string> GetObjectsFromFilter(ISelectionFilter filter, ISpeckleConverter converter)
{
var selection = new List <string>();
switch (filter.Slug)
{
case "manual":
return(GetSelectedObjects());
case "all":
return(Doc.ConvertibleObjects(converter));
case "layer":
foreach (var layerName in filter.Selection)
{
TypedValue[] layerType = new TypedValue[1] {
new TypedValue((int)DxfCode.LayerName, layerName)
};
PromptSelectionResult prompt = Doc.Editor.SelectAll(new SelectionFilter(layerType));
if (prompt.Status == PromptStatus.OK)
{
selection.AddRange(prompt.Value.GetHandles());
}
}
return(selection);
}
return(selection);
}
private List <string> GetObjectsFromFilter(ISelectionFilter filter, ISpeckleConverter converter)
{
switch (filter.Slug)
{
case "all":
return(Doc.ConvertibleObjects(converter));
case "layer":
var layerObjs = new List <string>();
foreach (var layerName in filter.Selection)
{
AcadDb.TypedValue[] layerType = new AcadDb.TypedValue[1] {
new AcadDb.TypedValue((int)AcadDb.DxfCode.LayerName, layerName)
};
PromptSelectionResult prompt = Doc.Editor.SelectAll(new SelectionFilter(layerType));
if (prompt.Status == PromptStatus.OK)
{
layerObjs.AddRange(prompt.Value.GetHandles());
}
}
return(layerObjs);
default:
RaiseNotification("Filter type is not supported in this app. Why did the developer implement it in the first place?");
return(new List <string>());
}
}
public static object TryConvertItemToSpeckle(object value, ISpeckleConverter converter)
{
object result = null;
if (value is null)
{
throw new Speckle.Core.Logging.SpeckleException("Null values are not supported, please clean your data tree.");
}
if (value is IGH_Goo)
{
value = value.GetType().GetProperty("Value").GetValue(value);
}
if (value is Base || value.GetType().IsSimpleType())
{
return(value);
}
if (converter.CanConvertToSpeckle(value))
{
return(converter.ConvertToSpeckle(value));
}
return(result);
}
/// <summary>
/// Workflow for casting a Base into a GH_Structure, taking into account potential Convertions. Pass Converter as null if you don't care for conversion.
/// </summary>
/// <param name="Converter"></param>
/// <param name="base"></param>
/// <returns></returns>
public static GH_Structure <IGH_Goo> ConvertToTree(ISpeckleConverter Converter, Base @base, Action <GH_RuntimeMessageLevel, string> onError = null)
{
var data = new GH_Structure <IGH_Goo>();
// Use the converter
// case 1: it's an item that has a direct conversion method, eg a point
if (Converter != null && Converter.CanConvertToNative(@base))
{
var converted = Converter.ConvertToNative(@base);
data.Append(TryConvertItemToNative(converted, Converter));
}
// We unpack automatically since we auto-wrapped it initially
// case 2: it's a wrapper Base
// 2a: if there's only one member unpack it
// 2b: otherwise return dictionary of unpacked members
else if (@base.IsWrapper())
{
var treeBuilder = new TreeBuilder(Converter)
{
ConvertToNative = Converter != null
};
data = treeBuilder.Build(@base[@base.GetDynamicMembers().ElementAt(0)]);
}
// Simple pass the SpeckleBase
else
{
onError(GH_RuntimeMessageLevel.Remark, "This object needs to be expanded.");
data.Append(new GH_SpeckleBase(@base));
}
return(data);
}
public BatchConverter()
{
var kit = KitManager.GetDefaultKit();
if (kit == null)
{
throw new SpeckleException("Cannot find the Objects Kit. Has it been copied to the Kits folder?");
}
if (Globals.RevitDocument != null)
{
_converter = kit.LoadConverter(Applications.DynamoRevit);
}
else
{
_converter = kit.LoadConverter(Applications.DynamoSandbox);
}
if (_converter == null)
{
throw new SpeckleException("Cannot find the Dynamo converter. Has it been copied to the Kits folder?");
}
// if in Revit, we have a doc, injected by the Extension
if (Globals.RevitDocument != null)
{
_converter.SetContextDocument(Globals.RevitDocument);
}
}
// Recurses through the commit object and flattens it. Returns list of Base objects with their bake layers
private List <Tuple <Base, string> > FlattenCommitObject(object obj, ISpeckleConverter converter, string layer, StreamState state, ref int count, bool foundConvertibleMember = false)
{
var objects = new List <Tuple <Base, string> >();
if (obj is Base @base)
{
if (converter.CanConvertToNative(@base))
{
objects.Add(new Tuple <Base, string>(@base, layer));
return(objects);
}
else
{
int totalMembers = @base.GetDynamicMembers().Count();
foreach (var prop in @base.GetDynamicMembers())
{
count++;
// get bake layer name
string objLayerName = prop.StartsWith("@") ? prop.Remove(0, 1) : prop;
string acLayerName = $"{layer}${objLayerName}";
var nestedObjects = FlattenCommitObject(@base[prop], converter, acLayerName, state, ref count, foundConvertibleMember);
if (nestedObjects.Count > 0)
{
objects.AddRange(nestedObjects);
foundConvertibleMember = true;
}
}
if (!foundConvertibleMember && count == totalMembers) // this was an unsupported geo
{
converter.Report.Log($"Skipped not supported type: { @base.speckle_type }. Object {@base.id} not baked.");
}
return(objects);
}
}
if (obj is List <object> list)
{
count = 0;
foreach (var listObj in list)
{
objects.AddRange(FlattenCommitObject(listObj, converter, layer, state, ref count));
}
return(objects);
}
if (obj is IDictionary dict)
{
count = 0;
foreach (DictionaryEntry kvp in dict)
{
objects.AddRange(FlattenCommitObject(kvp.Value, converter, layer, state, ref count));
}
return(objects);
}
return(objects);
}
/// <summary>
/// Recurses through the commit object and flattens it.
/// </summary>
/// <param name="obj"></param>
/// <param name="converter"></param>
/// <returns>List of Base objects with their bake layers</returns>
private List <Tuple <Base, string> > FlattenCommitObject(object obj, ISpeckleConverter converter, string layer, StreamState state)
{
var objects = new List <Tuple <Base, string> >();
if (obj is Base @base)
{
if (converter.CanConvertToNative(@base))
{
objects.Add(new Tuple <Base, string>(@base, layer));
return(objects);
}
else
{
if (@base.GetDynamicMembers().Count() == 0) // this was an unsupported geo
{
state.Errors.Add(new Exception($"Recieving {@base.speckle_type} objects is not supported. Object {@base.id} not baked."));
}
foreach (var prop in @base.GetDynamicMembers())
{
// get acad bake layer name
string objLayerName;
if (prop.StartsWith("@"))
{
objLayerName = prop.Remove(0, 1);
}
else
{
objLayerName = prop;
}
string acLayerName = $"{layer}${objLayerName}";
objects.AddRange(FlattenCommitObject(@base[prop], converter, acLayerName, state));
}
return(objects);
}
}
if (obj is List <object> list)
{
foreach (var listObj in list)
{
objects.AddRange(FlattenCommitObject(listObj, converter, layer, state));
}
return(objects);
}
if (obj is IDictionary dict)
{
foreach (DictionaryEntry kvp in dict)
{
objects.AddRange(FlattenCommitObject(kvp.Value, converter, layer, state));
}
return(objects);
}
return(objects);
}
public virtual void SetConverterFromKit(string kitName)
{
if (kitName == Kit?.Name)
{
return;
}
Kit = KitManager.Kits.FirstOrDefault(k => k.Name == kitName);
SelectedKitName = Kit.Name;
Converter = Kit.LoadConverter(Applications.Rhino);
Converter.SetContextDocument(Rhino.RhinoDoc.ActiveDoc);
Message = $"Using the {Kit.Name} Converter";
}
public void SetConverterFromKit(string kitName)
{
if (kitName == Kit.Name)
{
return;
}
Kit = KitManager.Kits.FirstOrDefault(k => k.Name == kitName);
Converter = Kit.LoadConverter(Applications.Rhino);
Message = $"Using the {Kit.Name} Converter";
ExpireSolution(true);
}
public BatchConverter()
{
var kit = KitManager.GetDefaultKit();
_converter = kit.LoadConverter(Applications.Dynamo);
if (_converter == null)
{
throw new Exception("Cannot find the Dynamo converter, has it been copied to the Kit folder?");
}
#if REVIT
_converter.SetContextDocument(Globals.RevitDocument);
#endif
}
private void SetDefaultKitAndConverter()
{
Kit = KitManager.GetDefaultKit();
try
{
Converter = Kit.LoadConverter(Applications.Rhino);
Converter.SetContextDocument(RhinoDoc.ActiveDoc);
}
catch
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "No default kit found on this machine.");
}
}
/// <summary>
/// conversion to native
/// </summary>
/// <param name="obj"></param>
/// <param name="state"></param>
/// <param name="converter"></param>
private void BakeObject(Base obj, StreamState state, ISpeckleConverter converter)
{
try
{
Tracker.TrackPageview(Tracker.CONVERT_TONATIVE);
converter.ConvertToNative(obj);
}
catch (Exception e)
{
var exception = new Exception($"Failed to convert object {obj.id} of type {obj.speckle_type}\n with error\n{e}");
converter.Report.LogOperationError(exception);
return;
}
}
public ExtendSpeckleObjectAsync() : base("Extend Speckle Object Async", "ESOA",
"Extend a current object with key/value pairs", "Speckle 2 Dev", "Async Object Management")
{
Kit = KitManager.GetDefaultKit();
try
{
Converter = Kit.LoadConverter(Applications.Rhino);
BaseWorker = new ExtendSpeckleObjectWorker(this, Converter);
Message = $"{Kit.Name} Kit";
}
catch
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "No default kit found on this machine.");
}
}
public GetObjectValueByKeyAsync() : base("Speckle Object Value by Key Async", "Object K/V A",
"Gets the value of a specific key in a Speckle object.", "Speckle 2 Dev", "Async Object Management")
{
Kit = KitManager.GetDefaultKit();
try
{
Converter = Kit.LoadConverter(Applications.Rhino);
BaseWorker = new GetObjectValueByKeyWorker(this, Converter);
Message = $"{Kit.Name} Kit";
}
catch
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "No default kit found on this machine.");
}
}
public virtual void SetConverterFromKit(string kitName)
{
if (kitName == Kit?.Name)
{
return;
}
Kit = KitManager.Kits.FirstOrDefault(k => k.Name == kitName);
SelectedKitName = Kit.Name;
Converter = Kit.LoadConverter(Applications.Rhino6);
Converter.SetConverterSettings(SpeckleGHSettings.MeshSettings);
SpeckleGHSettings.OnMeshSettingsChanged +=
(sender, args) => Converter.SetConverterSettings(SpeckleGHSettings.MeshSettings);
Converter.SetContextDocument(Rhino.RhinoDoc.ActiveDoc);
Message = $"Using the {Kit.Name} Converter";
}
/// <summary>
/// Traverses all keys of a given <see cref="Base"/> instance and attempts to convert any entities 'To Speckle'.
/// This method works recursively, and will traverse any Base instances it encounters that it cannot convert directly.
/// </summary>
/// <param name="base">Base object</param>
/// <param name="converter">Converter instance to use.</param>
/// <returns>A shallow copy of the base object with compatible values converted to Speckle entities.</returns>
public static Base TraverseAndConvertToSpeckle(Base @base, ISpeckleConverter converter, Action OnConversionProgress = null)
{
var subclass = @base.GetType().IsSubclassOf(typeof(Base));
if (subclass)
{
return(@base);
}
var copy = @base.ShallowCopy();
var keyValuePairs = copy.GetMembers().ToList();
keyValuePairs.ForEach(keyval =>
{
// TODO: Handle dicts!!
var value = keyval.Value;
if (value == null)
{
// TODO: Handle null values in properties here. For now, we just ignore that prop in the object
copy[keyval.Key] = null;
return;
}
if (value is IList list)
{
var converted = new List <object>();
foreach (var item in list)
{
var conv = TryConvertItemToSpeckle(item, converter, true);
converted.Add(conv);
}
copy[keyval.Key] = converted;
}
else if (typeof(IDictionary).IsAssignableFrom(value.GetType()))
{
var converted = new Dictionary <string, object>();
foreach (DictionaryEntry kvp in value as IDictionary)
{
converted[kvp.Key.ToString()] = TryConvertItemToSpeckle(kvp.Value, converter, true);
}
copy[keyval.Key] = converted;
}
else
{
copy[keyval.Key] = TryConvertItemToSpeckle(value, converter, true);
}
});
return(copy);
}
public static IGH_Goo TryConvertItemToNative(object value, ISpeckleConverter converter)
{
if (value == null)
{
return(null);
}
if (value is IGH_Goo)
{
value = value.GetType().GetProperty("Value")?.GetValue(value);
}
if (value is Base @base && converter.CanConvertToNative(@base))
{
var converted = converter.ConvertToNative(@base);
var geomgoo = GH_Convert.ToGoo(converted);
if (geomgoo != null)
{
return(geomgoo);
}
var goo = new GH_ObjectWrapper {
Value = converted
};
return(goo);
}
if (value is Base @base2)
{
var goo = new GH_SpeckleBase {
Value = @base2
};
return(goo);
}
if (value.GetType().IsSimpleType())
{
return(GH_Convert.ToGoo(value));
}
if (value is Enum)
{
var i = (Enum)value;
return(new GH_ObjectWrapper {
Value = i
});
}
return(null);
}
public CreateSpeckleObjectAsync() : base("Create Speckle Object Async", "CSOA",
"Allows you to create a Speckle object by setting its keys and values.",
"Speckle 2 Dev", "Async Object Management")
{
Kit = KitManager.GetDefaultKit();
try
{
Converter = Kit.LoadConverter(Applications.Rhino);
BaseWorker = new CreateSpeckleObjectWorker(this, Converter);
Message = $"{Kit.Name} Kit";
}
catch
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "No default kit found on this machine.");
}
}
public ExpandSpeckleObjectAsync() : base("Expand Speckle Object Async", "ESOA",
"Allows you to decompose a Speckle object in its constituent parts.",
"Speckle 2 Dev", "Async Object Management")
{
Kit = KitManager.GetDefaultKit();
try
{
Converter = Kit.LoadConverter(Applications.Rhino);
BaseWorker = new ExpandSpeckleObjectWorker(this, Converter);
Message = $"{Kit.Name} Kit";
}
catch
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "No default kit found on this machine.");
}
}
/// <summary>
/// Recurses through the commit object and flattens it.
/// </summary>
/// <param name="obj"></param>
/// <param name="converter"></param>
/// <returns></returns>
private List <Base> FlattenCommitObject(object obj, ISpeckleConverter converter)
{
List <Base> objects = new List <Base>();
if (obj is Base @base)
{
if (converter.CanConvertToNative(@base))
{
objects.Add(@base);
return(objects);
}
else
{
foreach (var prop in @base.GetDynamicMembers())
{
objects.AddRange(FlattenCommitObject(@base[prop], converter));
}
return(objects);
}
}
if (obj is List <object> list)
{
foreach (var listObj in list)
{
objects.AddRange(FlattenCommitObject(listObj, converter));
}
return(objects);
}
if (obj is IDictionary dict)
{
foreach (DictionaryEntry kvp in dict)
{
objects.AddRange(FlattenCommitObject(kvp.Value, converter));
}
return(objects);
}
else
{
converter.Report.Log($"Skipped object of type {obj.GetType()}, not supported.");
}
return(objects);
}
public SelectKitAsyncComponentBase(string name, string nickname, string description, string category, string subCategory) : base(name, nickname, description, category, subCategory)
{
var key = "Speckle2:kit.default.name";
var n = Grasshopper.Instances.Settings.GetValue(key, "Objects");
Kit = KitManager.GetKitsWithConvertersForApp(Applications.Rhino).FirstOrDefault(kit => kit.Name == n);
try
{
Converter = Kit.LoadConverter(Applications.Rhino);
Converter.SetContextDocument(Rhino.RhinoDoc.ActiveDoc);
Message = $"{Kit.Name} Kit";
}
catch
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "No default kit found on this machine.");
}
}
public override void AddedToDocument(GH_Document document)
{
base.AddedToDocument(document);
var key = "Speckle2:kit.default.name";
var n = Grasshopper.Instances.Settings.GetValue(key, "Objects");
try
{
Kit = KitManager.GetKitsWithConvertersForApp(Applications.Rhino).FirstOrDefault(kit => kit.Name == n);
Converter = Kit.LoadConverter(Applications.Rhino);
Converter.SetContextDocument(Rhino.RhinoDoc.ActiveDoc);
Message = $"{Kit.Name} Kit";
}
catch
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "No default kit found on this machine.");
}
}
public virtual void SetConverter()
{
if (SelectedKitName == "None")
{
Kit = null;
Converter = null;
Message = "No Conversion";
return;
}
try
{
SetConverterFromKit(SelectedKitName);
}
catch
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "No default kit found on this machine.");
}
}
private void SetDefaultKitAndConverter()
{
try
{
Kit = KitManager.GetDefaultKit();
Converter = Kit.LoadConverter(Applications.Rhino6);
Converter.SetConverterSettings(SpeckleGHSettings.MeshSettings);
SpeckleGHSettings.OnMeshSettingsChanged +=
(sender, args) => Converter.SetConverterSettings(SpeckleGHSettings.MeshSettings);
Converter.SetContextDocument(Rhino.RhinoDoc.ActiveDoc);
foundKit = true;
}
catch
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "No default kit found on this machine.");
foundKit = false;
}
}
public override void AddedToDocument(GH_Document document)
{
base.AddedToDocument(document);
try
{
Kit = KitManager.GetKitsWithConvertersForApp(Applications.Rhino6).FirstOrDefault(kit => kit.Name == SpeckleGHSettings.SelectedKitName);
Converter = Kit.LoadConverter(Applications.Rhino6);
Converter.SetContextDocument(Rhino.RhinoDoc.ActiveDoc);
Converter.SetConverterSettings(SpeckleGHSettings.MeshSettings);
SpeckleGHSettings.OnMeshSettingsChanged +=
(sender, args) => Converter.SetConverterSettings(SpeckleGHSettings.MeshSettings);
Message = $"{Kit.Name} Kit";
}
catch
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "No default kit found on this machine.");
}
}
/// <summary>
/// Try to convert a given object into native (Rhino) format.
/// </summary>
/// <param name="value">Object to convert</param>
/// <param name="converter">Converter instance to use.</param>
/// <param name="recursive">Indicates if any non-convertible <see cref="Base"/> instances should be traversed too.</param>
/// <returns>An <see cref="IGH_Goo"/> instance holding the converted object. </returns>
public static object TryConvertItemToSpeckle(object value, ISpeckleConverter converter, bool recursive = false, Action OnConversionProgress = null)
{
if (value is null)
{
throw new Exception("Null values are not allowed, please clean your data tree.");
}
if (value is IGH_Goo)
{
value = value.GetType().GetProperty("Value").GetValue(value);
}
if (value.GetType().IsSimpleType())
{
return(value);
}
if (converter.CanConvertToSpeckle(value))
{
return(converter.ConvertToSpeckle(value));
}
var subclass = value.GetType().IsSubclassOf(typeof(Base));
if (subclass)
{
// TODO: Traverse through dynamic props only.
return(value);
}
if (recursive && value is Base @base)
{
return(TraverseAndConvertToSpeckle(@base, converter));
}
if (value is Base @base2)
{
return(@base2);
}
return(null);
}
private Base ConvertGridLines(ISpeckleConverter converter, ProgressViewModel progress)
{
Base converted = null;
ITFApplication appInst = new TFApplicationList();
if (0 == appInst.GetProject(0, out ITFLoadableProjectList projList) && projList != null)
{
ITFLoadableProject proj = projList.AsTFLoadableProject;
if (null == proj)
{
progress.Report.ConversionErrors.Add(new Exception("Could not retrieve project for exporting gridlines"));
return(converted);
}
ITFDrawingGrid drawingGrid = null;
if (Control.InvokeRequired)
{
Control.Invoke((Action)(() => { proj.GetDrawingGrid(false, 0, out drawingGrid); }));
}
else
{
proj.GetDrawingGrid(false, 0, out drawingGrid);
}
if (null == drawingGrid)
{
progress.Report.ConversionErrors.Add(new Exception("Could not retrieve drawing grid for exporting gridlines"));
return(converted);
}
if (Control.InvokeRequired)
{
converted = (Base)Control.Invoke(new SpeckleConversionDelegate(converter.ConvertToSpeckle), new object[] { drawingGrid });
}
else
{
converted = converter.ConvertToSpeckle(drawingGrid);
}
}
return(converted);
}
/// <summary>
/// Gets the handles of all visible document objects that can be converted to Speckle
/// </summary>
/// <param name="doc"></param>
/// <param name="converter"></param>
/// <returns></returns>
public static List <string> ConvertibleObjects(this Document doc, ISpeckleConverter converter)
{
var objs = new List <string>();
using (Transaction tr = doc.Database.TransactionManager.StartTransaction())
{
BlockTable blckTbl = tr.GetObject(doc.Database.BlockTableId, OpenMode.ForRead) as BlockTable;
BlockTableRecord blckTblRcrd = tr.GetObject(blckTbl[BlockTableRecord.ModelSpace], OpenMode.ForRead) as BlockTableRecord;
foreach (ObjectId id in blckTblRcrd)
{
DBObject dbObj = tr.GetObject(id, OpenMode.ForRead);
if (converter.CanConvertToSpeckle(dbObj) && dbObj.Visible())
{
objs.Add(dbObj.Handle.ToString());
}
}
tr.Commit();
}
return(objs);
}
public void SetConverterFromKit(string kitName)
{
if (Kit == null)
{
return;
}
if (kitName == Kit.Name)
{
return;
}
Kit = KitManager.Kits.FirstOrDefault(k => k.Name == kitName);
Converter = Kit.LoadConverter(Applications.Rhino6);
Converter.SetConverterSettings(SpeckleGHSettings.MeshSettings);
SpeckleGHSettings.OnMeshSettingsChanged +=
(sender, args) => Converter.SetConverterSettings(SpeckleGHSettings.MeshSettings);
Message = $"Using the {Kit.Name} Converter";
ExpireSolution(true);
}
public void SetConverterFromKit(string kitName)
{
if (kitName == Kit.Name)
{
return;
}
try
{
Kit = KitManager.Kits.FirstOrDefault(k => k.Name == kitName);
Converter = Kit.LoadConverter(Applications.Rhino);
Converter.SetContextDocument(RhinoDoc.ActiveDoc);
Message = $"Using the {Kit.Name} Converter";
ExpireSolution(true);
}
catch (Exception e)
{
// TODO: handle this.
Console.WriteLine(e);
}
}
