private List <ApplicationPlaceholderObject> ConvertReceivedObjects(List <Base> objects, ISpeckleConverter converter, StreamState state)
{
var placeholders = new List <ApplicationPlaceholderObject>();
foreach (var @base in objects)
{
try
{
var convRes = converter.ConvertToNative(@base);
if (convRes is ApplicationPlaceholderObject placeholder)
{
placeholders.Add(placeholder);
}
else if (convRes is List <ApplicationPlaceholderObject> placeholderList)
{
placeholders.AddRange(placeholderList);
}
}
catch (Exception e)
{
state.Errors.Add(e);
}
}
return(placeholders);
}
/// <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);
}
private List <ApplicationPlaceholderObject> ConvertAndBakeReceivedObjects(List <Base> objects, ISpeckleConverter converter, StreamState state)
{
var placeholders = new List <ApplicationPlaceholderObject>();
var conversionProgressDict = new ConcurrentDictionary <string, int>();
conversionProgressDict["Conversion"] = 1;
foreach (var @base in objects)
{
if (state.CancellationTokenSource.Token.IsCancellationRequested)
{
placeholders = null;
break;
}
try
{
conversionProgressDict["Conversion"]++;
// wrapped in a dispatcher not to block the ui
SpeckleMicroStationOpenRoadsCommand.Bootstrapper.RootWindow.Dispatcher.Invoke(() =>
{
UpdateProgress(conversionProgressDict, state.Progress);
}, System.Windows.Threading.DispatcherPriority.Background);
var convRes = converter.ConvertToNative(@base);
if (convRes is ApplicationPlaceholderObject placeholder)
{
placeholders.Add(placeholder);
}
else if (convRes is List <ApplicationPlaceholderObject> placeholderList)
{
placeholders.AddRange(placeholderList);
}
// creating new elements, not updating existing!
var convertedElement = convRes as Element;
if (convertedElement != null)
{
var status = convertedElement.AddToModel();
if (status == StatusInt.Error)
{
state.Errors.Add(new Exception($"Failed to bake object {@base.id} of type {@base.speckle_type}."));
}
}
else
{
state.Errors.Add(new Exception($"Failed to convert object {@base.id} of type {@base.speckle_type}."));
}
}
catch (Exception e)
{
state.Errors.Add(e);
}
}
return(placeholders);
}
private List <ApplicationPlaceholderObject> ConvertAndBakeReceivedObjects(List <Base> objects, ISpeckleConverter converter, StreamState state, ProgressViewModel progress)
{
var placeholders = new List <ApplicationPlaceholderObject>();
var conversionProgressDict = new ConcurrentDictionary <string, int>();
conversionProgressDict["Conversion"] = 0;
Execute.PostToUIThread(() => progress.Max = state.SelectedObjectIds.Count());
Action updateProgressAction = () =>
{
conversionProgressDict["Conversion"]++;
progress.Update(conversionProgressDict);
};
foreach (var @base in objects)
{
if (progress.CancellationTokenSource.Token.IsCancellationRequested)
{
placeholders = null;
break;
}
try
{
var convRes = converter.ConvertToNative(@base);
if (convRes is ApplicationPlaceholderObject placeholder)
{
placeholders.Add(placeholder);
}
else if (convRes is List <ApplicationPlaceholderObject> placeholderList)
{
placeholders.AddRange(placeholderList);
}
// creating new elements, not updating existing!
var convertedElement = convRes as Element;
if (convertedElement != null)
{
var status = convertedElement.AddToModel();
if (status == StatusInt.Error)
{
converter.Report.LogConversionError(new Exception($"Failed to bake object {@base.id} of type {@base.speckle_type}."));
}
}
else
{
converter.Report.LogConversionError(new Exception($"Failed to convert object {@base.id} of type {@base.speckle_type}."));
}
}
catch (Exception e)
{
converter.Report.LogConversionError(e);
}
}
return(placeholders);
}
/// <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 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);
}
private List <ApplicationPlaceholderObject> ConvertReceivedObjects(List <Base> objects, ISpeckleConverter converter, StreamState state)
{
var placeholders = new List <ApplicationPlaceholderObject>();
var conversionProgressDict = new ConcurrentDictionary <string, int>();
conversionProgressDict["Conversion"] = 1;
foreach (var @base in objects)
{
if (state.CancellationTokenSource.Token.IsCancellationRequested)
{
placeholders = null;
break;
}
try
{
conversionProgressDict["Conversion"]++;
// wrapped in a dispatcher not to block the ui
SpeckleRevitCommand.Bootstrapper.RootWindow.Dispatcher.Invoke(() =>
{
UpdateProgress(conversionProgressDict, state.Progress);
}, System.Windows.Threading.DispatcherPriority.Background);
var convRes = converter.ConvertToNative(@base);
if (convRes is ApplicationPlaceholderObject placeholder)
{
placeholders.Add(placeholder);
}
else if (convRes is List <ApplicationPlaceholderObject> placeholderList)
{
placeholders.AddRange(placeholderList);
}
}
catch (Exception e)
{
state.Errors.Add(e);
}
}
return(placeholders);
}
private List <ApplicationPlaceholderObject> ConvertReceivedObjects(List <Base> objects, ISpeckleConverter converter, StreamState state, ProgressViewModel progress)
{
var placeholders = new List <ApplicationPlaceholderObject>();
var conversionProgressDict = new ConcurrentDictionary <string, int>();
conversionProgressDict["Conversion"] = 1;
foreach (var @base in objects)
{
if (progress.CancellationTokenSource.Token.IsCancellationRequested)
{
placeholders = null;
break;
}
try
{
conversionProgressDict["Conversion"]++;
// wrapped in a dispatcher not to block the ui
progress.Update(conversionProgressDict);
var convRes = converter.ConvertToNative(@base);
if (convRes is ApplicationPlaceholderObject placeholder)
{
placeholders.Add(placeholder);
}
else if (convRes is List <ApplicationPlaceholderObject> placeholderList)
{
placeholders.AddRange(placeholderList);
}
}
catch (Exception e)
{
progress.Report.LogConversionError(e);
}
}
return(placeholders);
}
/// <summary>
/// Try to convert a given object into native (Grasshopper) 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 IGH_Goo TryConvertItemToNative(object value, ISpeckleConverter converter, bool recursive = false)
{
if (converter == null)
{
return(new GH_ObjectWrapper(value));
}
if (value == null)
{
return(null);
}
if (value is IGH_Goo)
{
value = value.GetType().GetProperty("Value")?.GetValue(value);
}
if (value is Base @base)
{
if (converter.CanConvertToNative(@base))
{
try
{
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);
}
catch (Exception e)
{
converter.ConversionErrors.Add(new Exception($"Could not convert {@base}", e));
}
}
if (recursive)
{
// Object is base but cannot convert directly, traverse!!!
var x = TraverseAndConvertToNative(@base, converter);
return(new GH_SpeckleBase(x));
}
}
if (value is Base @base2)
{
return new GH_SpeckleBase {
Value = @base2
}
}
;
if (value.GetType().IsSimpleType())
{
return(GH_Convert.ToGoo(value));
}
if (value is Enum)
{
var i = (Enum)value;
return(new GH_ObjectWrapper {
Value = i
});
}
return(new GH_ObjectWrapper(value));
}
private void ConvertCommit(Base commitObject, ISpeckleConverter converter, StreamState state, ProgressViewModel progress, Stream stream, string id)
{
using (DocumentLock l = Doc.LockDocument())
{
using (Transaction tr = Doc.Database.TransactionManager.StartTransaction())
{
// set the context doc for conversion - this is set inside the transaction loop because the converter retrieves this transaction for all db editing when the context doc is set!
converter.SetContextDocument(Doc);
// keep track of conversion progress here
var conversionProgressDict = new ConcurrentDictionary <string, int>();
conversionProgressDict["Conversion"] = 0;
Execute.PostToUIThread(() => progress.Max = state.SelectedObjectIds.Count());
Action updateProgressAction = () =>
{
conversionProgressDict["Conversion"]++;
progress.Update(conversionProgressDict);
};
// keep track of any layer name changes for notification here
bool changedLayerNames = false;
// create a commit prefix: used for layers and block definition names
var commitPrefix = DesktopUI.Utils.Formatting.CommitInfo(stream.name, state.BranchName, id);
// give converter a way to access the commit info
Doc.UserData.Add("commit", commitPrefix);
// delete existing commit layers
try
{
DeleteBlocksWithPrefix(commitPrefix, tr);
DeleteLayersWithPrefix(commitPrefix, tr);
}
catch
{
converter.Report.LogOperationError(new Exception($"Failed to remove existing layers or blocks starting with {commitPrefix} before importing new geometry."));
}
// flatten the commit object to retrieve children objs
int count = 0;
var commitObjs = FlattenCommitObject(commitObject, converter, commitPrefix, state, ref count);
// open model space block table record for write
BlockTableRecord btr = (BlockTableRecord)tr.GetObject(Doc.Database.CurrentSpaceId, OpenMode.ForWrite);
// More efficient this way than doing this per object
var lineTypeDictionary = new Dictionary <string, ObjectId>();
var lineTypeTable = (LinetypeTable)tr.GetObject(Doc.Database.LinetypeTableId, OpenMode.ForRead);
foreach (ObjectId lineTypeId in lineTypeTable)
{
var linetype = (LinetypeTableRecord)tr.GetObject(lineTypeId, OpenMode.ForRead);
lineTypeDictionary.Add(linetype.Name, lineTypeId);
}
foreach (var commitObj in commitObjs)
{
// create the object's bake layer if it doesn't already exist
(Base obj, string layerName) = commitObj;
var converted = converter.ConvertToNative(obj);
var convertedEntity = converted as Entity;
if (convertedEntity != null)
{
if (GetOrMakeLayer(layerName, tr, out string cleanName))
{
// record if layer name has been modified
if (!cleanName.Equals(layerName))
{
changedLayerNames = true;
}
var res = convertedEntity.Append(cleanName);
if (res.IsValid)
{
// handle display
Base display = obj[@"displayStyle"] as Base;
if (display != null)
{
var color = display["color"] as int?;
var lineType = display["linetype"] as string;
var lineWidth = display["lineweight"] as double?;
if (color != null)
{
var systemColor = System.Drawing.Color.FromArgb((int)color);
convertedEntity.Color = Color.FromRgb(systemColor.R, systemColor.G, systemColor.B);
convertedEntity.Transparency = new Transparency(systemColor.A);
}
if (lineWidth != null)
{
convertedEntity.LineWeight = Utils.GetLineWeight((double)lineWidth);
}
if (lineType != null)
{
if (lineTypeDictionary.ContainsKey(lineType))
{
convertedEntity.LinetypeId = lineTypeDictionary[lineType];
}
}
}
tr.TransactionManager.QueueForGraphicsFlush();
}
else
{
progress.Report.LogConversionError(new Exception($"Failed to add converted object {obj.id} of type {obj.speckle_type} to the document."));
}
}
else
{
progress.Report.LogOperationError(new Exception($"Failed to create layer {layerName} to bake objects into."));
}
}
else if (converted == null)
{
progress.Report.LogConversionError(new Exception($"Failed to convert object {obj.id} of type {obj.speckle_type}."));
}
}
progress.Report.Merge(converter.Report);
if (changedLayerNames)
{
progress.Report.Log($"Layer names were modified: one or more layers contained invalid characters {Utils.invalidChars}");
}
// remove commit info from doc userdata
Doc.UserData.Remove("commit");
tr.Commit();
}
}
}
