Merge pull request #1391 from specklesystems/dev

dev -> main for release

Author: dogukankaratas

Connectors/Autocad/Speckle.Connectors.AutocadShared/HostApp/AutocadInstanceUnpacker.cs

@@ -40,6 +40,13 @@ public UnpackResult<AutocadRootObject> UnpackSelection(IEnumerable<AutocadRootOb
 
     foreach (var obj in objects)
     {
+      // Skip hidden attributes from the selection. Their values are kept on the InstanceProxy
+      // via GetInstanceAttributes, so we just avoid sending them as floating Text.
+      if (obj.Root is AttributeReference attrRef && (!attrRef.Visible || attrRef.Invisible))
+      {
+        continue;
+      }
+
       // Note: isDynamicBlock always returns false for a selection of doc objects. Instances of dynamic blocks are represented in the document as blocks that have
       // a definition reference to the anonymous block table record.
       if (obj.Root is BlockReference blockReference && !blockReference.IsDynamicBlock)
@@ -131,6 +138,12 @@ out List<InstanceProxy>? instanceProxiesWithSameDefinition
       foreach (ObjectId id in instance.AttributeCollection)
       {
         var reference = (AttributeReference)transaction.GetObject(id, OpenMode.ForRead);
+        // Skip hidden attributes. Their values are still kept on the InstanceProxy via
+        // GetInstanceAttributes, so we just avoid sending them as floating Text.
+        if (!reference.Visible || reference.Invisible)
+        {
+          continue;
+        }
         string refAppId = reference.GetSpeckleApplicationId();
         _instanceObjectsManager.AddAtomicObject(refAppId, new(reference, refAppId));
       }

Converters/Autocad/Speckle.Converters.AutocadShared/Speckle.Converters.AutocadShared.projitems

@@ -56,6 +56,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)ToHost\Geometry\PointToHostConverter.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ToSpeckle\DataObjectDisplayValueExtractor.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ToSpeckle\Geometry\ArcToSpeckleConverter.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)ToSpeckle\Geometry\AttributeDefinitionToSpeckleConverter.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ToSpeckle\Geometry\HatchToSpeckleConverter.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ToSpeckle\Geometry\MTextToSpeckleConverter.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ToSpeckle\Geometry\RegionToSpeckleConverter.cs" />

Converters/Autocad/Speckle.Converters.AutocadShared/ToSpeckle/Geometry/AttributeDefinitionToSpeckleConverter.cs

@@ -0,0 +1,29 @@
+using Speckle.Converters.Common;
+using Speckle.Converters.Common.Objects;
+using Speckle.Sdk.Models;
+
+namespace Speckle.Converters.Autocad.ToSpeckle.Geometry;
+
+// AttributeDefinition inherits from DBText. Without this converter, ATTDEF entities
+// falls back to DBTextToSpeckleConverter which reads `TextString`
+// The default attribute value, typically empty for a ATTDEF
+// The visible text in the drawing is the Tag, so we use that instead.
+[NameAndRankValue(typeof(ADB.AttributeDefinition), NameAndRankValueAttribute.SPECKLE_DEFAULT_RANK)]
+public class AttributeDefinitionToSpeckleConverter : IToSpeckleTopLevelConverter
+{
+  private readonly ITypedConverter<ADB.DBText, SA.Text> _textConverter;
+
+  public AttributeDefinitionToSpeckleConverter(ITypedConverter<ADB.DBText, SA.Text> textConverter)
+  {
+    _textConverter = textConverter;
+  }
+
+  public Base Convert(object target) => Convert((ADB.AttributeDefinition)target);
+
+  public SA.Text Convert(ADB.AttributeDefinition target)
+  {
+    SA.Text result = _textConverter.Convert(target);
+    result.value = !string.IsNullOrEmpty(target.Tag) ? target.Tag : target.TextString;
+    return result;
+  }
+}

Converters/Autocad/Speckle.Converters.AutocadShared/ToSpeckle/Raw/DBTextToSpeckleRawConverter.cs

@@ -1,3 +1,4 @@
+using System.Diagnostics.CodeAnalysis;
 using Speckle.Converters.Autocad.Helpers;
 using Speckle.Converters.Common;
 using Speckle.Converters.Common.Objects;
@@ -9,16 +10,19 @@ public class DBTextToSpeckleRawConverter : ITypedConverter<ADB.DBText, Text>
 {
   private readonly ITypedConverter<AG.Point3d, SOG.Point> _pointConverter;
   private readonly ITypedConverter<AG.Vector3d, SOG.Vector> _vectorConverter;
+  private readonly ITypedConverter<ADB.MText, Text> _mtextConverter;
   private readonly IConverterSettingsStore<AutocadConversionSettings> _settingsStore;
 
   public DBTextToSpeckleRawConverter(
     ITypedConverter<AG.Point3d, SOG.Point> pointConverter,
     ITypedConverter<AG.Vector3d, SOG.Vector> vectorConverter,
+    ITypedConverter<ADB.MText, Text> mtextConverter,
     IConverterSettingsStore<AutocadConversionSettings> settingsStore
   )
   {
     _pointConverter = pointConverter;
     _vectorConverter = vectorConverter;
+    _mtextConverter = mtextConverter;
     _settingsStore = settingsStore;
   }
 
@@ -27,12 +31,23 @@ IConverterSettingsStore<AutocadConversionSettings> settingsStore
   /// </summary>
   /// <param name="target">The AutoCAD DBText to convert.</param>
   /// <returns>The converted Speckle Text object.</returns>
-  public Text Convert(ADB.DBText target) =>
+  public Text Convert(ADB.DBText target)
+  {
+    // Multi-line attributes are backed by an MText. Convert via the MText converter so the
+    // viewer keeps the wrap and renders multiple lines.
+    if (TryGetBackingMText(target, out ADB.MText? mtext))
+    {
+      using (mtext)
+      {
+        return _mtextConverter.Convert(mtext);
+      }
+    }
+
     // target.WidthFactor is ignored, because we don't support 1-dimensional text scaling
     // AlignmentPoint can be ignored, as, if used for positioning, it will be already reflected in Rotation and Height
-    new()
+    return new()
     {
-      value = target.TextString,
+      value = target.TextString ?? string.Empty,
       height = target.Height,
       maxWidth = null, // always 1 line
       plane = GetTextPlane(target),
@@ -41,6 +56,23 @@ public Text Convert(ADB.DBText target) =>
       alignmentV = AlignmentVertical.Bottom, // constant relevant to Position (.Justify & .Alignment Point can be ignored)
       units = _settingsStore.Current.SpeckleUnits,
     };
+  }
+
+  private static bool TryGetBackingMText(ADB.DBText target, [NotNullWhen(true)] out ADB.MText? mtext)
+  {
+    switch (target)
+    {
+      case ADB.AttributeReference attRef when attRef.IsMTextAttribute:
+        mtext = attRef.MTextAttribute;
+        return true;
+      case ADB.AttributeDefinition attDef when attDef.IsMTextAttributeDefinition:
+        mtext = attDef.MTextAttributeDefinition;
+        return true;
+      default:
+        mtext = null;
+        return false;
+    }
+  }
 
   // For DBText, the following properties are stored in:
   // - Position: WCS

Converters/Autocad/Speckle.Converters.AutocadShared/ToSpeckle/Raw/MTextToSpeckleRawConverter.cs

@@ -1,3 +1,4 @@
+using System.Text.RegularExpressions;
 using Speckle.Converters.Common;
 using Speckle.Converters.Common.Objects;
 
@@ -28,7 +29,7 @@ IConverterSettingsStore<AutocadConversionSettings> settingsStore
   public SA.Text Convert(ADB.MText target) =>
     new()
     {
-      value = target.Text,
+      value = ConvertMTextToPlainText(target.Contents ?? string.Empty),
       height = target.TextHeight,
       maxWidth = target.Width,
       plane = GetTextPlane(target),
@@ -38,6 +39,32 @@ public SA.Text Convert(ADB.MText target) =>
       units = _settingsStore.Current.SpeckleUnits,
     };
 
+  // Codes with parameters that end in `;` (font, color, height, etc.)
+  private static readonly Regex s_paramCodeRegex = new(@"\\[A-Za-z][^\\;]*;", RegexOptions.Compiled);
+
+  // Toggle codes with no parameters (underline, overline, strikethrough)
+  private static readonly Regex s_toggleCodeRegex = new(@"\\[LlOoKkX]", RegexOptions.Compiled);
+
+  /// <summary>
+  /// Turns raw MText contents into plain text with real newlines, so the viewer can render it
+  /// on multiple lines. Covers common formatting; exotic cases may still need cleanup.
+  /// </summary>
+  private static string ConvertMTextToPlainText(string contents)
+  {
+    if (string.IsNullOrEmpty(contents))
+    {
+      return contents;
+    }
+
+    // Convert paragraph breaks first so they aren't eaten by the strip below.
+    string result = contents.Replace("\\P", "\n");
+    result = s_paramCodeRegex.Replace(result, string.Empty);
+    result = s_toggleCodeRegex.Replace(result, string.Empty);
+    result = result.Replace("\\~", " ");
+    result = result.Replace("{", string.Empty).Replace("}", string.Empty);
+    return result;
+  }
+
   // For MText, the following properties are stored in:
   // - Position: WCS
   // - Normal: WCS??

Converters/Plant3d/Speckle.Converters.Plant3dShared/ToSpeckle/Geometry/Plant3dEntityToSpeckleConverter.cs

@@ -1,3 +1,4 @@
+using Speckle.Converters.Autocad.Extensions;
 using Speckle.Converters.Common.Objects;
 using Speckle.Converters.Common.Registration;
 using Speckle.Objects.Data;
@@ -66,9 +67,17 @@ private List<Base> ExtractDisplayValue(ADB.Entity entity)
   /// </summary>
   private void CollectDisplayObjects(ADB.Entity entity, List<Base> results, int depth)
   {
+    // ATTDEFs in a block definition hold the field template (e.g. "#(TargetObject.Type)"),
+    // not the rendered text. The real string lives on each instance's AttributeReference,
+    // which we capture below from the parent BlockReference's AttributeCollection.
+    if (entity is ADB.AttributeDefinition)
+    {
+      return;
+    }
+
     // If this is NOT a block reference, try converting it directly
     // (Line, Arc, Circle, Polyline, Solid3d, etc.)
-    if (entity is not ADB.BlockReference)
+    if (entity is not ADB.BlockReference blockRef)
     {
       try
       {
@@ -83,6 +92,32 @@ private void CollectDisplayObjects(ADB.Entity entity, List<Base> results, int de
         // Fall through to explode on ConversionNotSupportedException or failed
       }
     }
+    else
+    {
+      // AttributeReference inherits from DBText, so it resolves
+      // the existing DBText converter without any template parsing on our side.
+      foreach (
+        ADB.AttributeReference attRef in blockRef.GetSubEntities<ADB.AttributeReference>(
+          source: blockRef.AttributeCollection
+        )
+      )
+      {
+        if (!attRef.Visible || string.IsNullOrWhiteSpace(attRef.TextString))
+        {
+          continue;
+        }
+
+        try
+        {
+          var converter = _converterManager.ResolveConverter(attRef.GetType());
+          results.Add(converter.Convert(attRef));
+        }
+        catch (System.Exception)
+        {
+          // Skip any attribute reference we can't convert; continue with the rest.
+        }
+      }
+    }
 
     // For BlockReferences or unconvertible entities, explode to get sub-entities
     // Explode produces world-coordinate geometry (block transform is applied)

Converters/Revit/Speckle.Converters.RevitShared/ToSpeckle/Properties/ClassPropertiesExtractor.cs

@@ -91,21 +91,8 @@ public class ClassPropertiesExtractor
           elementProperties.Add("fromRoomApplicationId", familyInstance.FromRoom.UniqueId.ToString());
         }
 
-        Element? parent = null;
-
-#if REVIT2023_OR_GREATER
-        BuiltInCategory bic = familyInstance.Category.BuiltInCategory;
-#else
-        // Cast for 2022 and older
-        BuiltInCategory bic = (BuiltInCategory)familyInstance.Category.Id.IntegerValue;
-#endif
-
-        if (bic == BuiltInCategory.OST_CurtainWallMullions || bic == BuiltInCategory.OST_CurtainWallPanels)
-        {
-          parent = familyInstance.Host;
-        }
-
-        parent ??= familyInstance.SuperComponent;
+        // parent: prefer Host (e.g. wall, floor, ceiling), fall back to SuperComponent (nested family)
+        Element? parent = familyInstance.Host ?? familyInstance.SuperComponent;
 
         if (parent != null)
         {