Through the Interface

Inserting a specific Excel sheet as an AutoCAD table using .NET

Last week I received the following question from Adam Schilling:

I have enjoyed your posts on .net programming for datalinks. I have searched high and low and haven’t been able to find answers or any support to help me with a small issue. 

My code (much of which was based off of your posts from 2007) works fine, except I cannot get it to use a different sheet from the workbook that is select.  Since the option to select a specific sheet is available when adding a link manually, I would think that it would be possible to programmatically do it also.

If it would work for a post great, if not, I apologize for taking your time.

Seeing as Adam asked so nicely (and I found the question to be of broad interest, which is also important), I went ahead and dusted off the 6-year old posts that he’d referred to. [Has it really been that long since I wrote them? Sigh.]

Here’s the series that I’ve refreshed for the purposes of this post:

1. Creating an AutoCAD table linked to an Excel spreadsheet using .NET

2. Updating an AutoCAD table linked to an Excel spreadsheet using .NET

3. Updating an Excel spreadsheet from a linked AutoCAD table using .NET

It’s really the code from the first that has been modified to allow selection of a specific sheet, but the code was all in the same file (and the compiler warned of some obsolete functions), so I decided to update the other commands, too, rather than stripping them out.

The quick answer to Adam’s question is that you can specify a particular sheet to link to by passing its name (using the “!” character as a separator) into the DataLink’s ConnectionString property. e.g.:

dl.ConnectionString = "spreadsheet.xlsx!Sheet2";

That’s really all there is to it. But that would make for a pretty short post, so I went ahead and added some code that, for a selected spreadsheet, presents the list of contained sheets to the user and asks for one to be selected.

While not really being what the post is about – the main point is to show the AutoCAD side of things – there are a few different ways to access the contents of an Excel spreadsheet from .NET.

The one I’d personally have preferred to have used is the OleDb provider for Office. The problem with that approach relates to getting the right version of the component working for your app, even though 32- and 64-bit versions are both available (at least for Office 2010, for Office 2007 there’s just the 32-bit version).

Here’s my own situation, as an example: I’m running 32-bit Office on a 64-bit system (the main reason being that’s the way our IT department supports it, as far as I can tell), which means the installer doesn’t let me install the 64-bit component (probably because it needs to match the underlying Office version, which I suppose is fair enough). But while I can install the 32-bit version, my .NET application inside AutoCAD needs to be either x64 or “Any CPU”, and so leads to the “The 'Microsoft.ACE.OLEDB.12.0' provider is not registered on the local machine” exception being thrown when the connection attempt is made.

Which led me back to using the COM library for Excel, instead (for which I added a COM project reference to the “Microsoft Excel 14.0 Object Library”). Using this component actually fires up an instance of Excel in the background – which certainly seems like overkill just to access the list of sheets contained in a spreadsheet – but it’s reliable and easy to get working. And the code is certainly more readable.

Speaking of the code, here’s the updated C# code letting a user select a specific Excel sheet for insertion (in the TFS command):

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Windows;

using System.Collections.Generic;

using Excel = Microsoft.Office.Interop.Excel;

 

namespace LinkToExcel

{

  public class Commands

  {

    [CommandMethod("S2T")]

    static public void UpdateTableFromSpreadsheet()

    {

      var doc =

        Application.DocumentManager.MdiActiveDocument;

      var db = doc.Database;

      var ed = doc.Editor;

 

      var opt = new PromptEntityOptions("\nSelect table to update");

      opt.SetRejectMessage("\nEntity is not a table.");

      opt.AddAllowedClass(typeof(Table), false);     

 

      var per = ed.GetEntity(opt);

      if (per.Status != PromptStatus.OK)

        return;

 

      using (var tr = db.TransactionManager.StartTransaction())

      {

        try

        {

          var obj = tr.GetObject(per.ObjectId, OpenMode.ForRead);

          var tb = obj as Table;

 

          // It should always be a table

          // but we'll check, just in case

 

          if (tb != null)

          {

            // The table must be open for write

 

            tb.UpgradeOpen();

 

            // Update data link from the spreadsheet

 

            var dlIds = tb.Cells.GetDataLink();

 

            foreach (ObjectId dlId in dlIds)

            {

              var dl =

                (DataLink)tr.GetObject(dlId, OpenMode.ForWrite);

              dl.Update(

                UpdateDirection.SourceToData,

                UpdateOption.None

              );

 

              // And the table from the data link

 

              tb.UpdateDataLink(

                UpdateDirection.SourceToData,

                UpdateOption.None

              );

            }

          }

          tr.Commit();

          ed.WriteMessage(

            "\nUpdated the table from the spreadsheet."

          );

        }

        catch (Exception ex)

        {

          ed.WriteMessage(

            "\nException: {0}",

            ex.Message

          );

        }

      }

    }

 

    [CommandMethod("T2S")]

    static public void UpdateSpreadsheetFromTable()

    {

      var doc =

        Application.DocumentManager.MdiActiveDocument;

      var db = doc.Database;

      var ed = doc.Editor;

 

      var opt =

        new PromptEntityOptions(

          "\nSelect table with spreadsheet to update"

        );

      opt.SetRejectMessage(

        "\nEntity is not a table."

      );

      opt.AddAllowedClass(typeof(Table), false);

 

      var per = ed.GetEntity(opt);

      if (per.Status != PromptStatus.OK)

        return;

 

      Transaction tr =

        db.TransactionManager.StartTransaction();

      using (tr)

      {

        try

        {

          DBObject obj =

            tr.GetObject(per.ObjectId, OpenMode.ForRead);

          Table tb = obj as Table;

 

          // It should always be a table

          // but we'll check, just in case

 

          if (tb != null)

          {

            // The table must be open for write

 

            tb.UpgradeOpen();

 

            // Update the data link from the table

 

            tb.UpdateDataLink(

              UpdateDirection.DataToSource,

              UpdateOption.ForceFullSourceUpdate

            );

 

            // And the spreadsheet from the data link

 

            var dlIds = tb.Cells.GetDataLink();

            foreach (ObjectId dlId in dlIds)

            {

              var dl =

                (DataLink)tr.GetObject(dlId, OpenMode.ForWrite);

              dl.Update(

                UpdateDirection.DataToSource,

                UpdateOption.ForceFullSourceUpdate

              );

            }

          }

          tr.Commit();

 

          ed.WriteMessage(

            "\nUpdated the spreadsheet from the table."

          );

        }

        catch (Exception ex)

        {

          ed.WriteMessage("\nException: {0}", ex.Message);

        }

      }

    }

 

    static public List<string> GetSheetNames(string excelFileName)

    {

      var listSheets = new List<string>();

 

      var excel = new Excel.Application();

      var wbs = excel.Workbooks.Open(excelFileName);

      foreach (Excel.Worksheet sheet in wbs.Worksheets)

      {

        listSheets.Add(sheet.Name);

      }

      excel.Quit();

 

      return listSheets;

    }

 

    [CommandMethod("TFS")]

    static public void TableFromSpreadsheet()

    {

      const string dlName = "Import table from Excel demo";

 

      var doc =

        Application.DocumentManager.MdiActiveDocument;

      var db = doc.Database;

      var ed = doc.Editor;

 

      // Ask the user to select an XLS(X) file

 

      var ofd =

        new OpenFileDialog(

          "Select Excel spreadsheet to link",

          null,

          "xls; xlsx",

          "ExcelFileToLink",

          OpenFileDialog.OpenFileDialogFlags.

            DoNotTransferRemoteFiles

        );

 

      var dr = ofd.ShowDialog();

 

      if (dr != System.Windows.Forms.DialogResult.OK)

        return;

 

      // Display the name of the file and the contained sheets

 

      ed.WriteMessage(

        "\nFile selected was \"{0}\". Contains these sheets:",

        ofd.Filename

      );

 

      // First we get the sheet names

 

      var sheetNames = GetSheetNames(ofd.Filename);

 

      if (sheetNames.Count == 0)

      {

        ed.WriteMessage(

          "\nWorkbook doesn't contain any sheets."

        );

        return;

      }

 

      // And loop through, printing their names

 

      for (int i=0; i < sheetNames.Count; i++)

      {

        var name = sheetNames[i];

 

        ed.WriteMessage("\n{0} - {1}", i + 1, name);

      }

 

      // Ask the user to select one

 

      var pio = new PromptIntegerOptions("\nSelect a sheet");

      pio.AllowNegative = false;

      pio.AllowZero = false;

      pio.DefaultValue = 1;

      pio.UseDefaultValue = true;

      pio.LowerLimit = 1;

      pio.UpperLimit = sheetNames.Count;

 

      var pir = ed.GetInteger(pio);

      if (pir.Status != PromptStatus.OK)

        return;

 

      // Ask for the insertion point of the table

 

      var ppr = ed.GetPoint("\nEnter table insertion point");

      if (ppr.Status != PromptStatus.OK)

        return;

 

      // Remove any Data Link, if one exists already

 

      var dlm = db.DataLinkManager;

      var dlId = dlm.GetDataLink(dlName);

      if (dlId != ObjectId.Null)

      {

        dlm.RemoveDataLink(dlId);

      }

 

      // Create and add the new Data Link, this time with

      // a direction connection to the selected sheet

 

      var dl = new DataLink();

      dl.DataAdapterId = "AcExcel";

      dl.Name = dlName;

      dl.Description = "Excel fun with Through the Interface";

      dl.ConnectionString =

        ofd.Filename + "!" + sheetNames[pir.Value - 1];

      dl.DataLinkOption =

        DataLinkOption.PersistCache;

      dl.UpdateOption |=

        (int)UpdateOption.AllowSourceUpdate;

 

      dlId = dlm.AddDataLink(dl);

 

      using (var tr = doc.TransactionManager.StartTransaction())

      {

        tr.AddNewlyCreatedDBObject(dl, true);

 

        var bt =

          (BlockTable)tr.GetObject(

            db.BlockTableId,

            OpenMode.ForRead

          );

 

        // Create our table

 

        var tb = new Table();

        tb.TableStyle = db.Tablestyle;

        tb.Position = ppr.Value;

        tb.Cells.SetDataLink(dlId, true);

        tb.GenerateLayout();

 

        // Add it to the drawing

 

        var btr =

          (BlockTableRecord)tr.GetObject(

            db.CurrentSpaceId,

            OpenMode.ForWrite

          );

 

        btr.AppendEntity(tb);

        tr.AddNewlyCreatedDBObject(tb, true);

        tr.Commit();

      }

    }

  }

}

When we run the TFS command, we see the user gets presented with the usual file selection dialog, but then a command-line interface for choosing a specific sheet from the selected spreadsheet:

Command: TFS

File selected was "C:\Data\Spreadsheet.xlsx". Contains these sheets:

1 - Sheet1

2 - Sheet2

3 - Sheet3

Select a sheet <1>: 2

Enter table insertion point:

Which results in the specified sheet getting inserted as a table into the current AutoCAD drawing.

Maintaining per-object XData in AutoCAD using .NET

As a follow-on from this recent post, I decided to take a stab at a more generic solution for managing XData that should remain unique – i.e. attached to a single object – inside an AutoCAD drawing. This was prompted by an internal discussion that included a long-time colleague, Randy Kintzley, who suggested the approach taken in this post. (Thanks also to Tekno Tandean and Davis Augustine for adding valuable comments/feedback.)

Randy’s suggestion was to avoid per-command event handling completely by adding an additional piece of XData – the handle – to objects that need to be managed in this way. The beauty of this approach is that you don’t need to check on the various ways that objects can be duplicated/copied/cloned inside AutoCAD – you simply compare the handle in the XData with that of the owning object and if they’re the same then the data is valid. If they’re different then you can take action either to make the data valid or to remove it from what’s basically a copy of the original object.

As for when you perform this integrity check: that’s ultimately up to you – the least intrusive approach is probably to perform it “just in time”, when the objects are selected by the user and/or processed programmatically. You could make sure it happens “just in case” (i.e. on an ongoing basis), but that would add avoidable execution overhead.

There are some points to note regarding this:

• The handle needs to be stored as something other than a handle (e.g. using group-code 1000 – a string – rather than 1005), to make sure it doesn’t get translated automatically when the original object is copied. I’ve gone and added a prefix to this string, to make sure it doesn’t get confused with other data (and it also allows me not to rely on the item of XData existing in a specific location in the list – something you may choose to rely upon in your own application).
• Handles will get reassigned – and the XData invalidated – when objects get wblocked (or inserted) into a drawing. Which means the data will (always?) become invalid on wblock – and that’s probably OK, you can strip it when it’s next handled by your app – but you clearly don’t want to have a “false positive” where the object happens to have the same handle as the original. You could mitigate for this by also adding the fingerprint GUID of the originating drawing in the XData, but there’s memory and storage overhead associated with that, of course. This is left for the reader to implement based on their specific needs.

Here’s some C# code that implements this basic approach:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

 

namespace ExtendedEntityData

{

  public class Commands

  {

    const string appName = "KEAN";

    const string handPref = "HND:";

 

    [CommandMethod("SELXD")]

    public void SelectWithXData()

    {

      var doc = Application.DocumentManager.MdiActiveDocument;

      var ed = doc.Editor;

 

      // We'll filter our selection to only include entities with

      // our XData attached

 

      var tv = new TypedValue(1001, appName);

      var sf = new SelectionFilter(new TypedValue[] { tv });

 

      // Ask the user to select (filtered) entities

 

      var res = ed.GetSelection(sf);

 

      if (res.Status != PromptStatus.OK)

        return;

 

      // We'll collect our valid and invalid IDs in two collections

 

      var valid = new ObjectIdCollection();

      var invalid = new ObjectIdCollection();

 

      using (var tr = doc.TransactionManager.StartTransaction())

      {

        FindValidStripInvalid(

          tr, tv, res.Value.GetObjectIds(), valid, invalid

        );

        tr.Commit();

      }

 

      ed.WriteMessage(

        "\nFound {0} objects with valid XData, " +

        "stripped {1} objects of invalid XData.",

        valid.Count,

        invalid.Count

      );

    }

 

    private void FindValidStripInvalid(

      Transaction tr,

      TypedValue root,

      ObjectId[] ids,

      ObjectIdCollection valid,

      ObjectIdCollection invalid,

      bool strip = true

    )

    {

      foreach (var id in ids)

      {

        // Look for the "HND:" value anywhere in our app's

        // XData (this could be changed to look at a specific

        // location)

 

        bool found = false;

 

        // Start by opening each object for read and get the XData

        // we care about

 

        var obj = tr.GetObject(id, OpenMode.ForRead);

        using (

          var rb = obj.GetXDataForApplication((string)root.Value)

        )

        {

          // Check just in case something got passed in that doesn't

          // have our XData

 

          if (rb != null)

          {

            foreach (TypedValue tv in rb)

            {

              // If we have a string value...

 

              if (tv.TypeCode == 1000)

              {

                var val = tv.Value.ToString();

 

                // That starts with our prefix...

 

                if (val.StartsWith(handPref))

                {

                  // And matches the object's handle...

 

                  if (val == handPref + obj.Handle.ToString())

                  {

                    // ... then it's a valid object

 

                    valid.Add(id);

                    found = true;

                  }

                  else

                    break; // Handle prefix found with bad handle

                }

              }

            }

          }

          if (!found)

          {

            // We have an invalid handle reference (or none at all).

            // Optionally strip the XData from this object

 

            invalid.Add(id);

            if (strip)

            {

              obj.UpgradeOpen();

              obj.XData = new ResultBuffer(root);

            }

          }

        }

      }

    }

 

    [CommandMethod("GXD")]

    public void GetXData()

    {

      var doc = Application.DocumentManager.MdiActiveDocument;

      var ed = doc.Editor;

 

      // Ask the user to select an entity

      // for which to retrieve XData

 

      var opt = new PromptEntityOptions("\nSelect entity");

      var res = ed.GetEntity(opt);

 

      if (res.Status == PromptStatus.OK)

      {

        using (var tr = doc.TransactionManager.StartTransaction())

        {

          var obj = tr.GetObject(res.ObjectId, OpenMode.ForRead);

          using (var rb = obj.XData)

          {

            if (rb == null)

            {

              ed.WriteMessage(

                "\nEntity does not have XData attached."

              );

            }

            else

            {

              int n = 0;

              foreach (TypedValue tv in rb)

              {

                ed.WriteMessage(

                  "\nTypedValue {0} - type: {1}, value: {2}",

                  n++,

                  tv.TypeCode,

                  tv.Value

                );

              }

            }

          }

        }

      }

    }

 

    [CommandMethod("SXD")]

    public void SetXData()

    {

      var doc = Application.DocumentManager.MdiActiveDocument;

      var ed = doc.Editor;

 

      // Ask the user to select an entity

      // for which to set XData

 

      var opt = new PromptEntityOptions("\nSelect entity");

      var res = ed.GetEntity(opt);

 

      if (res.Status == PromptStatus.OK)

      {

        using (var tr = doc.TransactionManager.StartTransaction())

        {

          var obj = tr.GetObject(res.ObjectId, OpenMode.ForWrite);

          AddRegAppTableRecord(tr, doc.Database, appName);

          var rb =

            new ResultBuffer(

              new TypedValue(1001, appName),

              new TypedValue(1000, "This is a test string"),

              new TypedValue(1000, handPref + obj.Handle.ToString())

            );

          using (rb)

          {

            obj.XData = rb;

          }

          tr.Commit();

        }

      }

    }

 

    private void AddRegAppTableRecord(

      Transaction tr, Database db, string name

    )

    {

      var rat =

        (RegAppTable)tr.GetObject(

          db.RegAppTableId,

          OpenMode.ForRead

        );

      if (!rat.Has(name))

      {

        rat.UpgradeOpen();

        var ratr = new RegAppTableRecord();

        ratr.Name = name;

        rat.Add(ratr);

        tr.AddNewlyCreatedDBObject(ratr, true);

      }

    }

  }

}

I’ve tried to keep the code fairly bare-bones (which no doubt means there’s plenty of room for improvement :-).

It implements a helper function – FindValidStripInvalid() – to filter valid from invalid objects (optionally stripping the XData from the invalid ones). The SELXD command asks the user to select objects – filtering on those with our XData attached – and then passes them into this helper function.

This means, of course, that the selection process may report more objects have been selected than will later prove to be valid, but if that’s undesirable then a different approach is probably warranted (whether to filter them out “just in case” or to choose a completely different mechanism). And yes, this also means that your app’s “selection” process can no longer necessarily be considered a read-only operation: we’re introducing a database side-effect that might otherwise be at odds with your application’s behaviour. Again, the choice is yours: cleaning up at another time is certainly an option.

To see the code in action, try using the SXD command to add XData to a few entities inside an AutoCAD drawing. COPY or OFFSET these entities (multiple times, if you wish) and then use the GXD command to see what data is attached to a few of the objects. Running the SELXD and selecting everything will report the number of objects selected with valid XData and clean up the XData attached to any “invalid”, cloned objects.

As mentioned, this is a fairly simple implementation of the concept. There may well be further cases that you have to code for, depending on the behaviour you need in your application, but feel free to kick the tyres and let me know your feedback.

Update:

It turns out I've suggested an alternative approach to solving this problem, in the past. That approach uses an API introduced in AutoCAD 2010 and so is clearly only valid for the releases since then, in case that's a determining factor for your application. Otherwise both approaches remain valid, with pros and cons discussed in this post's comments thread.

Filtering lists of AutoCAD entities using LINQ

A comment on the last post made me think it’s probably worth diving into LINQ a bit further, as there’s clearly interest out there. Now I don’t actually use LINQ very much but whenever I do I tell myself I ought to use it more – it’s really very useful.

A lot of LINQ is derived from the world of Functional Programming – in that it allows you to use higher order functions to manipulate data – and it’s really just another way in which .NET languages have been influenced by FP (and have evolved to incorporate its techniques in their increasingly multi-paradigm nature). This is a good thing.

When I think about using LINQ, I therefore tend to think back to “functional” languages – whether F# or LISP – to think about the types of operation that would streamline the process I’m trying to implement.

In the last post, we wanted to return the tail of a list (which means everything but the head, i.e. the first item). I chose to pass in the PromptSelectionResult object, as I felt it was more efficient to work from that directly:

private static ObjectId[] AllButFirst(PromptSelectionResult psr)

{

  // Use LINQ to skip the first item in the IEnumerable

  // and then return the results as an ObjectId array

 

  return

    psr.Value.Cast<SelectedObject>().Skip(1).

      Select(o => { return o.ObjectId; }).ToArray();

}

Breaking this down a little, we perform a cast on the contents of the IEnumerable (the Value property of PromptSelectionResult is a SelectionSet, which implements the IEnumerable interface), so that we know they’re SelectedObjects, and Skip the first of these results before using Select() to essentially map to a list of the referenced ObjectIds. And then we call ToArray() on the results to return an array of ObjectIds.

This is all well and good, but it’s a little specific to selection (in that it takes a PromptSelectionResult parameter). To generalise the behaviour – and make it ultimately more flexible – we can adjust the function to take an ObjectId array instead (as this is also an enumerable data-type in .NET):

private static ObjectId[] AllButFirst(ObjectId[] arr)

{

  return arr.Skip<ObjectId>(1).ToArray();

}

This is a bit simpler – as we no longer need to cast to an enumerable list of SelectedObjects and then map from these to ObjectIds – but means that we’re going to have to pass in an ObjectId array from the PromptSelectionResult object. We can do this via the GetObjectIds() method, which we assume (and this is really an important point) will return an array of ObjectIds in the order in which the objects were selected.

Let’s take a look at another example of using LINQ… this time we’ll essentially use it to filter a list of ObjectIds based on the type of object each belongs to. Here’s one version, which uses the LINQ extension methods to do the work in much the same way as we’ve seen above:

private static ObjectId[] OnlyOfClass(ObjectId[] ids, RXClass c)

{

  return

    ids.Where(id => { return id.ObjectClass == c; }).ToArray();

}

The beauty of this technique is that we don’t even need to open the object: the ObjectId class has a property that returns the type of the identified object. If we did need to go further, then it’d probably make sense to use the dynamic capabilities of ObjectId to open and close the associated object implicitly. But that’s for another day.

Now let’s rework the code a little to use the more elegant and “language-integrated” form (which is really just syntactic sugar – I haven’t actually taken the time to check but would expect the generated IL to be very similar if not identical).

private static ObjectId[] OnlyOfClass2(ObjectId[] ids, RXClass c)

{

  return

    (from id in ids where id.ObjectClass == c select id).ToArray();

}

To give these functions a try, let's now implement a quick command that allows you to select a bunch of objects and filter the results. I haven’t bothered implementing multiple commands for the different function alternatives (or to try with different object types) – that’s been left up to the reader.

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using System.Linq;

 

namespace SelectionManipulation

{

  public class Commands

  {

    [CommandMethod("SELFIL")]

    static public void FilterSelection()

    {

      var doc = Application.DocumentManager.MdiActiveDocument;

      var ed = doc.Editor;

 

      var psr = ed.GetSelection();

      if (psr.Status != PromptStatus.OK)

        return;

 

      var ids =

        OnlyOfClass(

          psr.Value.GetObjectIds(),

          RXClass.GetClass(typeof(Line))

        );

 

      using (var tr = doc.TransactionManager.StartTransaction())

      {

        ed.WriteMessage("\nFound {0} objects.", ids.Length);

 

        foreach (var id in ids)

        {

          var obj = tr.GetObject(id, OpenMode.ForRead);

 

          ed.WriteMessage(

            "\nThis object is really a {0}.", obj.GetType().Name

          );

        }

        tr.Commit();

      }

    }

 

    private static ObjectId[] AllButFirst(ObjectId[] arr)

    {

      return arr.Skip<ObjectId>(1).ToArray();

    }

 

    private static ObjectId[] OnlyOfClass(

      ObjectId[] ids, RXClass c

    )

    {

      return

        ids.Where(id => { return id.ObjectClass == c; }).ToArray();

    }

 

    private static ObjectId[] OnlyOfClass2(

      ObjectId[] ids, RXClass c

    )

    {

      return

        (from id in ids where id.ObjectClass == c select id).

        ToArray();

    }

  }

}

When we run the SELFIL command and select a number of entities – not all of which are lines – we will see something like this reported to the command-line:

Command: SELFIL

Select objects: Specify opposite corner: 8 found

Select objects:

Found 5 objects.

This object is really a Line.

This object is really a Line.

This object is really a Line.

This object is really a Line.

This object is really a Line.

In most cases, I’d expect people to want to implement a SelectionFilter to have this more “up-front” in the process – just as we saw last time for the user to only select Solid3d objects – but there are definitely cases where this is helpful. RealDWG clients, for instance, don’t have the Editor available to integrate more closely with AutoCAD’s selection mechanism, and so really need some way to easily filter large sets of entities. This approach should certainly help in that situation.

photo credit: James Jordan via photopin cc

Performing Boolean operations on AutoCAD solids using .NET

I looked back and couldn’t find a post covering this particular topic and so decided to put something together. It may well have been covered elsewhere (I admit to not having looked) but I felt like throwing some code together, either way. :-)

To perform a Boolean operation between Solid3d objects inside AutoCAD, you can use Solid3d.BooleanOperation() on the primary Solid3d, passing in the secondary one.

We want to implement commands for Unite (or Union), Intersect (Intersection) and Subtract (Subtraction). Only the last of these needs us to select a primary object explicitly – as the other two operations are associative – but we’ll go ahead and implement a generic function that takes a separate primary object as an argument. In the case of Unite and Intersect, we’ll simply take the first element of the selected solids and pass that in as the primary object (being sure to remove it from the “secondary” list we pass in).

That’s really all there is to it. Here’s the C# code that defined USOLS, ISOLS and SSOLS command (for union, intersection and subtraction respectively).

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using System.Linq;

 

namespace BooleanSolids

{

  public class Commands

  {

    [CommandMethod("USOLS")]

    static public void UniteSolids()

    {

      var doc = Application.DocumentManager.MdiActiveDocument;

 

      var psr =

        SelectSolids(

          doc.Editor,

          "\nSelect solid objects to unite"

        );

      if (psr.Status != PromptStatus.OK)

        return;

 

      if (psr.Value.Count > 1)

      {

        BooleanSolids(

          doc, psr.Value[0].ObjectId, AllButFirst(psr),

          BooleanOperationType.BoolUnite

        );

      }

    }

 

    [CommandMethod("ISOLS")]

    static public void IntersectSolids()

    {

      var doc = Application.DocumentManager.MdiActiveDocument;

 

      var psr =

        SelectSolids(

          doc.Editor,

          "\nSelect solid objects to intersect"

        );

      if (psr.Status != PromptStatus.OK)

        return;

 

      if (psr.Value.Count > 1)

      {

        BooleanSolids(

          doc, psr.Value[0].ObjectId, AllButFirst(psr),

          BooleanOperationType.BoolIntersect

        );

      }

    }

 

    [CommandMethod("SSOLS")]

    static public void SubtractSolids()

    {

      var doc = Application.DocumentManager.MdiActiveDocument;

      var ed = doc.Editor;

 

      var first = SelectSingleSolid(ed, "\nSelect primary solid");

      if (first == ObjectId.Null)

        return;

 

      var psr = SelectSolids(ed, "\nSelect solids to subtract");

      if (psr.Status != PromptStatus.OK)

        return;

 

      if (psr.Value.Count > 0)

      {

        BooleanSolids(

          doc, first, psr.Value.GetObjectIds(),

          BooleanOperationType.BoolSubtract

        );

      }

    }

 

    private static ObjectId SelectSingleSolid(

      Editor ed, string prompt

    )

    {

      var peo = new PromptEntityOptions(prompt);

      peo.SetRejectMessage("\nMust be a 3D solid");

      peo.AddAllowedClass(typeof(Solid3d), false);

 

      var per = ed.GetEntity(peo);

      if (per.Status != PromptStatus.OK)

        return ObjectId.Null;

 

      return per.ObjectId;

    }

 

    private static ObjectId[] AllButFirst(PromptSelectionResult psr)

    {

      // Use LINQ to skip the first item in the IEnumerable

      // and then return the results as an ObjectId array

 

      return

        psr.Value.Cast<SelectedObject>().Skip(1).

          Select(o => { return o.ObjectId; }).ToArray();

    }

 

    private static PromptSelectionResult SelectSolids(

      Editor ed, string prompt

    )

    {

      // Set up our selection to only select 3D solids

 

      var pso = new PromptSelectionOptions();

      pso.MessageForAdding = prompt;

 

      var sf =

        new SelectionFilter(

          new TypedValue[]

          {

            new TypedValue((int)DxfCode.Start, "3DSOLID")

          }

        );

 

      return ed.GetSelection(pso, sf);

    }

 

    private static void BooleanSolids(

      Document doc, ObjectId first, ObjectId[] others,

      BooleanOperationType op

    )

    {

      var tr = doc.TransactionManager.StartTransaction();

      using (tr)

      {

        var sol =

          tr.GetObject(first, OpenMode.ForWrite) as Solid3d;

 

        if (sol != null)

        {

          foreach (ObjectId id in others)

          {

            var sol2 =

              tr.GetObject(id, OpenMode.ForWrite) as Solid3d;

 

            if (sol2 != null)

            {

              sol.BooleanOperation(op, sol2);

            }

          }

        }

        tr.Commit();

      }

    }

  }

}.

A framework for defining AutoCAD entity jigs using .NET

In the last post we saw some code to create a frustum-shaped Solid3d object inside AutoCAD. I mentioned at the bottom of that post that there seemed to be an opportunity to write a framework of some kind to abstract away some of the repetitive code needed to create a multi-input jig. I probably didn’t say it in quite that way, but that was what I was getting at. :-)

Anyway, after having looked at it some more, here’s what I came up with: the EntityJigFramework. It’s a class derived from EntityJig that encapsulates some of the common code you’d otherwise need to write when creating a “complex” jig.

It’s still very much a work in progress – I’ve added support for JigPrompts.AcquireString(), AcquirePoint(), AcquireDistance() and AcquireAngle() in the various “phases” (more on that later), but there’s probably still work needed to make them fully functional – but I thought I’d put it out there for feedback, anyway.

Here’s the C# EntityJigFramework implementation, as it stands:

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Geometry;

using System.Collections.Generic;

using System;

 

namespace JigFrameworks

{

  // Our jig framework class

 

  public enum PhaseType

  {

    Distance = 0,

    Point,

    Angle,

    String

  }

 

  // For each input item to be requested by the user, we have a

  // "phase" object passed into the jig

 

  public class Phase

  {

    public Phase(

      string msg,

      PhaseType t = PhaseType.Distance,

      object defval = null,

      Func<List<Phase>, Point3d, Vector3d> offset = null

    )

    {

      // Each phase has a type - depending on the type of data

      // being requested - a message, and optionally an offset

      // from the base point passed into the jig and a default

      // value

 

      Type = t;

      Message = msg;

      Offset = offset;

 

      // Initialise the relevant value property to the default

      // value, if provided

 

      if (t == PhaseType.Distance)

      {

        DoubleValue = (defval == null ? 1e-05 : (double)defval);

      }

      else if (t == PhaseType.Point)

      {

        PointValue =

          (defval == null ? Point3d.Origin : (Point3d)defval);

      }

      else if (t == PhaseType.String)

      {

        StringValue =

          (defval == null ? "" : (string)defval);

      }

      else if (t == PhaseType.Angle)

      {

        DoubleValue = (defval == null ? 0 : (double)defval);

      }

    }

 

    // Our member data (could add real properties, as needed)

 

    public PhaseType Type;

    public string Message;

    public Func<List<Phase>, Point3d, Vector3d> Offset;

 

    // The value we use will depend on the type (we could

    // probably use some kind of union here)

 

    public double DoubleValue;

    public string StringValue;

    public Point3d PointValue;

  };

 

  public class EntityJigFramework : EntityJig

  {

    // Member data

 

    Matrix3d _ucs;

    Point3d _cen;

    Entity _ent;

    List<Phase> _phases;

    int _phase;

    Func<Entity, List<Phase>, Point3d, Matrix3d, bool> _update;

 

    // Constructor

 

    public EntityJigFramework(

      Matrix3d ucs, Entity ent, Point3d cen,

      List<Phase> phases,

      Func<Entity, List<Phase>, Point3d, Matrix3d, bool> update

    ) : base(ent)

    {

      _ucs = ucs;

      _ent = ent;

      _cen = cen;

      _phases = phases;

      _phase = 0;

      _update = update;

    }

 

    // Move on to the next phase

 

    internal void NextPhase()

    {

      _phase++;

    }

 

    // Check whether we're at the last phase

 

    internal bool IsLastPhase()

    {

      return (_phase == _phases.Count - 1);

    }

 

    // EntityJig protocol

 

    protected override SamplerStatus Sampler(JigPrompts prompts)

    {

      // Get the current phase

 

      Phase p = _phases[_phase];

 

      // If we're dealing with a geometry-typed phase (distance,

      // point ot angle input) we can use some common code

 

      if (p.Type < PhaseType.String)

      {

        JigPromptGeometryOptions opts;

        switch (p.Type)

        {

          case PhaseType.Distance:

            opts = new JigPromptDistanceOptions();

            break;

          case PhaseType.Point:

            opts = new JigPromptPointOptions();

            break;

          case PhaseType.Angle:

            opts = new JigPromptAngleOptions();

            break;

          default: // Should never happen

            opts = null;

            break;

        }

 

        // Set up the user controls

 

        opts.UserInputControls =

          (UserInputControls.Accept3dCoordinates

          | UserInputControls.NoZeroResponseAccepted

          | UserInputControls.NoNegativeResponseAccepted);

 

        // All our distance inputs will be with a base point

        // (which means the initial base point or an offset from

        // that)

 

        opts.UseBasePoint = true;

        opts.Cursor = CursorType.RubberBand;

 

        opts.Message = p.Message;

        opts.BasePoint =

          (p.Offset == null ?

            _cen.TransformBy(_ucs) :

            (_cen + p.Offset.Invoke(_phases, _cen)).TransformBy(_ucs)

          );

 

        // The acquisition method varies on the phase type

 

        switch (p.Type)

        {

          case PhaseType.Distance:

            var pdr =

              prompts.AcquireDistance(

                (JigPromptDistanceOptions)opts

              );

 

            if (pdr.Status == PromptStatus.OK)

            {

              // If the difference between the new value and its

              // previous value is negligible, return "no change"

 

              if (

                Math.Abs(_phases[_phase].DoubleValue - pdr.Value) <

                Tolerance.Global.EqualPoint

              )

                return SamplerStatus.NoChange;

 

              // Otherwise we update the appropriate variable

              // based on the phase

 

              _phases[_phase].DoubleValue = pdr.Value;

              return SamplerStatus.OK;

            }

            break;

          case PhaseType.Point:

            var ppr =

              prompts.AcquirePoint((JigPromptPointOptions)opts);

 

            if (ppr.Status == PromptStatus.OK)

            {

              // If the difference between the new value and its

              // previous value is negligible, return "no change"

 

              if (

                (_phases[_phase].PointValue - ppr.Value).Length <

                Tolerance.Global.EqualPoint

              )

                return SamplerStatus.NoChange;

 

              // Otherwise we update the appropriate variable

              // based on the phase

 

              _phases[_phase].PointValue = ppr.Value;

              return SamplerStatus.OK;

            }

            break;

          case PhaseType.Angle:

            var par =

              prompts.AcquireAngle((JigPromptAngleOptions)opts);

 

            if (par.Status == PromptStatus.OK)

            {

              // If the difference between the new value and its

              // previous value is negligible, return "no change"

 

              if (

                _phases[_phase].DoubleValue - par.Value <

                Tolerance.Global.EqualPoint

              )

                return SamplerStatus.NoChange;

 

              // Otherwise we update the appropriate variable

              // based on the phase

 

              _phases[_phase].DoubleValue = par.Value;

              return SamplerStatus.OK;

            }

            break;

          default:

            break;

        }

      }

      else

      {

        // p.Type == PhaseType.String

 

        var psr = prompts.AcquireString(p.Message);

 

        if (psr.Status == PromptStatus.OK)

        {

          _phases[_phase].StringValue = psr.StringResult;

          return SamplerStatus.OK;

        }

      }

      return SamplerStatus.Cancel;

    }

 

    protected override bool Update()

    {

      // Right now we have an indiscriminate catch around our

      // entity update callback: this could be modified to be

      // more selective and/or to provide information on exceptions

 

      try

      {

        return _update.Invoke(_ent, _phases, _cen, _ucs);

      }

      catch

      {

        return false;

      }

    }

 

    public Entity GetEntity()

    {

      return Entity;

    }

 

    // Our method to perform the jig and step through the

    // phases until done

 

    internal void RunTillComplete(Editor ed, Transaction tr)

    {

      // Perform the jig operation in a loop

 

      while (true)

      {

        var res = ed.Drag(this);

 

        if (res.Status == PromptStatus.OK)

        {

          if (!IsLastPhase())

          {

            // Progress the phase

 

            NextPhase();

          }

          else

          {

            // Only commit when all phases have been accepted

 

            tr.Commit();

            return;

          }

        }

        else

        {

          // The user has cancelled: returning aborts the

          // transaction

 

          return;

        }

      }

    }

  }

}

The basic idea is that you pass a list of “phase” objects – each of which defines a specific piece of data that needs to be acquired from the user – into your  framework’s constructor, along with a function to be called when your entity gets updated.

This function hopefully receives the information it needs to allow the entity to be updated – for now it gets the entity itself, the list of our phase data (the most important part of this being the values that have been acquired from the user), the “start point” and the current UCS. If there’s something else that needs passing through, it’s simple enough to modify the framework to do so.

You might notice in the phase object that there’s the option to specify a default value. I’ve been lazy here, and for the “distance” property I’ve set the hard-coded default to 1e-05 (i.e. 0.00001), as this is a value that allows the Solid3d.CreateFrustum() (and its counterparts) to consider the value as non-zero, so the calls don’t fail. I will probably modify the framework to set the hard-coded default to zero and the client code to pass in 1e-05 via the constructor to each phase object for distance acquisition, at some point.

So here’s how we can now reduce the C# code for our frustum jig:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Geometry;

using System.Collections.Generic;

using System;

using JigFrameworks;

 

namespace EntityJigs

{

  public class Commands

  {

    [CommandMethod("FJ")]

    public void FrustumJig()

    {

      var doc =

        Application.DocumentManager.MdiActiveDocument;

      var db = doc.Database;

      var ed = doc.Editor;

 

      // First let's get the start position of the frustum

 

      var ppr = ed.GetPoint("\nSpecify frustum location: ");

 

      if (ppr.Status == PromptStatus.OK)

      {

        // In order for the visual style to be respected,

        // we'll add the to-be-jigged solid to the database

 

        Transaction tr =

          doc.TransactionManager.StartTransaction();

        using (tr)

        {

          var btr =

            (BlockTableRecord)tr.GetObject(

              db.CurrentSpaceId, OpenMode.ForWrite

            );

 

          var sol = new Solid3d();

          btr.AppendEntity(sol);

          tr.AddNewlyCreatedDBObject(sol, true);

 

          // Create our jig object passing in the selected point

 

          var jf =

            new EntityJigFramework(

              ed.CurrentUserCoordinateSystem, sol, ppr.Value,

              new List<Phase>()

              {

                // Three phases, one of which has a custom

                // offset for the base point

 

                new Phase("\nSpecify bottom radius: "),

                new Phase("\nSpecify height: "),

                new Phase(

                  "\nSpecify top radius: ",

                  PhaseType.Distance,

                  1e-05,

                  (vals, pt) =>

                  {

                    return new Vector3d(0, 0, vals[1].DoubleValue);

                  }

                )

              },

              (e, vals, cen, ucs) =>

              {

                // Our entity update function

 

                Solid3d s = (Solid3d)e;

                s.CreateFrustum(

                  vals[1].DoubleValue,

                  vals[0].DoubleValue,

                  vals[0].DoubleValue,

                  vals[2].DoubleValue

                );

                s.TransformBy(

                  Matrix3d.Displacement(

                    cen.GetAsVector() +

                    new Vector3d(0, 0, vals[1].DoubleValue / 2)

                  ).PreMultiplyBy(ucs)

                );

                return true;

              }

            );

          jf.RunTillComplete(ed, tr);

        }

      }

    }

  }

}

Running the code results in exactly the same behaviour as before, as you might expect.

Much of the start of the above function is also fairly “boilerplate”, in that the jig framework might also own the transaction and the initial point selection, but I felt leaving that outside the framework provides more flexibility (even if it means more code needs copy & pasting – and ultimately maintaining – each time you create a new jig).

In a future post, I’ll go ahead and use this framework to implement further jigs for AutoCAD objects, to make sure it’s flexible enough.

Creating a selection filter that finds dynamic blocks in AutoCAD using .NET

An interesting question came in via email from Rob Outman. He’s interested in applying a selection filter when the user selects dynamic blocks. This is straightforward for unmodified dynamic blocks – just as with standard blocks, you can filter on the block name very easily – but it works less well on dynamic blocks whose properties have been modified at an instance level.

Essentially what happens is this: if you select a block reference to a dynamic block in the AutoCAD editor and then use (for example) the Properties window to edit some of the custom properties associated with that block, the block definition gets duplicated as an anonymous block – with the modified properties, of course – and the reference gets updated to point to that. If you LIST the block reference, you can see that it still mentions the originating block by name, so it’s clear some connection still exists between the two block definitions, at the very least.

This makes it a little difficult to use a SelectionFilter to look for these BlockReference objects, as their associated BlockTableRecord has a name such as “*U24” rather than the name being searched for.

The answer to this riddle was actually reasonably straightforward, in the end. Using the very handy ArxDbg sample, it was easy to find out that the modified block definition contains XData linking back to the original – under the AcDbBlockRepBTag app name there’s an entry containing its handle – which we can use to compile a list of the (anonymous) names of modified blocks for which to look.

We can then create a conditional SelectionFilter – with an “or” clause listing each of these names – and use that to find any block meeting the condition.

Here’s the C# code that does all this:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using System.Collections.Generic;

 

namespace EntitySelection

{

  public class Commands

  {

    [CommandMethod("SDB")]

    static public void SelectDynamicBlocks()

    {

      var doc = Application.DocumentManager.MdiActiveDocument;

      var ed = doc.Editor;

 

      var pso =

        new PromptStringOptions(

          "\nName of dynamic block to search for"

        );

      pso.AllowSpaces = true;

 

      var pr = ed.GetString(pso);

 

      if (pr.Status != PromptStatus.OK)

        return;

 

      string blkName = pr.StringResult;

 

      List<string> blkNames = new List<string>();

      blkNames.Add(blkName);

 

      var tr = doc.TransactionManager.StartTransaction();

      using (tr)

      {

        var bt =

          (BlockTable)tr.GetObject(

            doc.Database.BlockTableId,

            OpenMode.ForRead

          );

 

        // Start by getting the handle of our block, if it exists

 

        if (!bt.Has(blkName))

        {

          ed.WriteMessage(

            "\nCannot find block called \"{0}\".", blkName

          );

          return;

        }

 

        var btr =

          (BlockTableRecord)tr.GetObject(

            bt[blkName], OpenMode.ForRead

          );

 

        var blkHand = btr.Handle;

 

        foreach (var bid in bt)

        {

          // We'll check each block in turn, to see if it has

          // XData pointing to our original block definition

 

          var btr2 =

            (BlockTableRecord)tr.GetObject(bid, OpenMode.ForRead);

 

          // Only check blocks that don't share the name :-)

 

          if (btr2.Name != blkName)

          {

            // And only check blocks with XData

 

            var xdata = btr2.XData;

            if (xdata != null)

            {

              // Get the XData as an array of TypeValues and loop

              // through it

 

              var tvs = xdata.AsArray();

              for (int i=0; i < tvs.Length; i++)

              {

                // The first value should be the RegAppName

 

                var tv = tvs[i];

                if (

                  tv.TypeCode == (int)DxfCode.ExtendedDataRegAppName

                )

                {

                  // If it's the one we care about...

 

                  if ((string)tv.Value == "AcDbBlockRepBTag")

                  {

                    // ... then loop through until we find a

                    // handle matching our blocks or otherwise

                    // another RegAppName

 

                    for (int j = i + 1; j < tvs.Length; j++)

                    {

                      tv = tvs[j];

                      if (

                        tv.TypeCode ==

                          (int)DxfCode.ExtendedDataRegAppName

                      )

                      {

                        // If we have another RegAppName, then

                        // we'll break out of this for loop and

                        // let the outer loop have a chance to

                        // process this section

 

                        i = j - 1;

                        break;

                      }

 

                      if (

                        tv.TypeCode ==

                          (int)DxfCode.ExtendedDataHandle

                      )

                      {

                        // If we have a matching handle...

 

                        if ((string)tv.Value == blkHand.ToString())

                        {

                          // ... then we can add the block's name

                          // to the list and break from both loops

                          // (which we do by setting the outer index

                          // to the end)

 

                          blkNames.Add(btr2.Name);

                          i = tvs.Length - 1;

                          break;

                        }

                      }

                    }

                  }

                }

              }

            }

          }

        }

 

        tr.Commit();

      }

 

      // Build a conditional filter list so that only

      // entities with the specified properties are

      // selected

 

      SelectionFilter sf =

        new SelectionFilter(CreateFilterListForBlocks(blkNames));

      PromptSelectionResult psr = ed.SelectAll(sf);

 

      ed.WriteMessage(

        "\nFound {0} entit{1}.",

        psr.Value.Count,

        (psr.Value.Count == 1 ? "y" : "ies")

      );

    }

 

    private static TypedValue[] CreateFilterListForBlocks(

      List<string> blkNames

    )

    {

      // If we don't have any block names, return null

 

      if (blkNames.Count == 0)

        return null;

 

      // If we only have one, return an array of a single value

 

      if (blkNames.Count == 1)

        return new TypedValue[] {

          new TypedValue(

            (int)DxfCode.BlockName,

           blkNames[0]

          )

        };

 

      // We have more than one block names to search for...

 

      // Create a list big enough for our block names plus

      // the containing "or" operators

 

      List<TypedValue> tvl =

        new List<TypedValue>(blkNames.Count + 2);

 

      // Add the initial operator

 

      tvl.Add(

        new TypedValue(

          (int)DxfCode.Operator,

          "<or"

        )

      );

 

      // Add an entry for each block name, prefixing the

      // anonymous block names with a reverse apostrophe

 

      foreach (var blkName in blkNames)

      {

        tvl.Add(

          new TypedValue(

            (int)DxfCode.BlockName,

            (blkName.StartsWith("*") ? "`" + blkName : blkName)

          )

        );

      }

 

      // Add the final operator

 

      tvl.Add(

        new TypedValue(

          (int)DxfCode.Operator,

          "or>"

        )

      );

 

      // Return an array from the list

 

      return tvl.ToArray();

    }

  }

}

An interesting point to note: we need to prefix any anonymous block name with an inverted apostrophe (“`”) character, as that seems to be the way to “escape” asterisks in this situation.

Let’s see this in action. We’ll start by loading the standard “Dynamic Blocks/Annotation – Metric.dwg” sample into AutoCAD, and inserting a number of “Elevation – Metric” dynamic blocks into the drawing:

We can then use the Properties window to edit the Custom properties on each:

Which leads to branched block definitions:

We can then use the SDB command to select our the block references for both the original dynamic block definition and its modified, branched copies.

Command: SDB

Name of dynamic block to search for: Elevation - Metric

Found 5 entities.

Update:

Thanks to Roland Feletic for pointing me to the GetAnonymousBlockIds() function that I’d manage to overlook or forget about. Roland passed on some code he’d received from Tony Tanzillo, so thanks to Tony, too (although all I took was the method name :-).

The use of this function does simplify the code nicely, as well as reducing the dependence on the XData link (which is ultimately an implementation detail).

Here’s the updated C# code, which works in the same way as the prior version:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using System.Collections.Generic;

 

namespace EntitySelection

{

  public class Commands

  {

    [CommandMethod("SDB")]

    static public void SelectDynamicBlocks()

    {

      var doc = Application.DocumentManager.MdiActiveDocument;

      var ed = doc.Editor;

 

      var pso =

        new PromptStringOptions(

          "\nName of dynamic block to search for"

        );

      pso.AllowSpaces = true;

 

      var pr = ed.GetString(pso);

 

      if (pr.Status != PromptStatus.OK)

        return;

 

      string blkName = pr.StringResult;

 

      List<string> blkNames = new List<string>();

      blkNames.Add(blkName);

 

      var tr = doc.TransactionManager.StartTransaction();

      using (tr)

      {

        var bt =

          (BlockTable)tr.GetObject(

            doc.Database.BlockTableId,

            OpenMode.ForRead

          );

 

        // Start by getting access to our block, if it exists

 

        if (!bt.Has(blkName))

        {

          ed.WriteMessage(

            "\nCannot find block called \"{0}\".", blkName

          );

          return;

        }

 

        // Get the anonymous block names

        var btr =

          (BlockTableRecord)tr.GetObject(

            bt[blkName], OpenMode.ForRead

          );

 

        if (!btr.IsDynamicBlock)

        {

          ed.WriteMessage(

            "\nCannot find a dynamic block called \"{0}\".", blkName

          );

          return;

        }

 

        // Get the anonymous blocks and add them to our list

 

        var anonBlks = btr.GetAnonymousBlockIds();

        foreach (ObjectId bid in anonBlks)

        {

          var btr2 =

            (BlockTableRecord)tr.GetObject(bid, OpenMode.ForRead);

 

          blkNames.Add(btr2.Name);

        }

 

        tr.Commit();

      }

 

      // Build a conditional filter list so that only

      // entities with the specified properties are

      // selected

 

      SelectionFilter sf =

        new SelectionFilter(CreateFilterListForBlocks(blkNames));

      PromptSelectionResult psr = ed.SelectAll(sf);

 

      ed.WriteMessage(

        "\nFound {0} entit{1}.",

        psr.Value.Count,

        (psr.Value.Count == 1 ? "y" : "ies")

      );

    }

 

    private static TypedValue[] CreateFilterListForBlocks(

      List<string> blkNames

    )

    {

      // If we don't have any block names, return null

 

      if (blkNames.Count == 0)

        return null;

 

      // If we only have one, return an array of a single value

 

      if (blkNames.Count == 1)

        return new TypedValue[] {

          new TypedValue(

            (int)DxfCode.BlockName,

           blkNames[0]

          )

        };

 

      // We have more than one block names to search for...

 

      // Create a list big enough for our block names plus

      // the containing "or" operators

 

      List<TypedValue> tvl =

        new List<TypedValue>(blkNames.Count + 2);

 

      // Add the initial operator

 

      tvl.Add(

        new TypedValue(

          (int)DxfCode.Operator,

          "<or"

        )

      );

 

      // Add an entry for each block name, prefixing the

      // anonymous block names with a reverse apostrophe

 

      foreach (var blkName in blkNames)

      {

        tvl.Add(

          new TypedValue(

            (int)DxfCode.BlockName,

            (blkName.StartsWith("*") ? "`" + blkName : blkName)

          )

        );

      }

 

      // Add the final operator

 

      tvl.Add(

        new TypedValue(

          (int)DxfCode.Operator,

          "or>"

        )

      );

 

      // Return an array from the list

 

      return tvl.ToArray();

    }

  }

}

Creating reactive, transient AutoCAD geometry using .NET

This is a really interesting topic. At least I think it is – hopefully at least some of you will agree. :-)

The requirement was to create selectable – or at least manipulatable – transient graphics inside AutoCAD’s drawing canvas. As many of you are probably aware, transient graphics are not hooked into AutoCAD’s selection mechanism. This is mostly fine, but if you want to implement a ViewCube-like gizmo that manipulates the view or drawing settings in some way, it’s hard to do so without the ability to react to the current cursor position is and what’s happening with the mouse.

When my esteemed colleague, Christer Janson, first pointed me at the internal C++ protocol extension that allows you to receive Windows messages and point input inside your application, I assumed there was no chance I’d be able to get this working in .NET (as it’s not exposed through the public ObjectARX API). But after some digging and head-scratching, I managed to find how it had been exposed via the .NET API and create a sample that makes use of it.

Here’s the C# code, showing how to use this very interesting mechanism:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.GraphicsInterface;

 

namespace TransientSelection

{

  public class SelectableTransient : Transient

  {

    // Windows messages we care about

 

    const int WM_LBUTTONDOWN = 513;

    const int WM_LBUTTONUP = 514;

 

    // Internal state

 

    Entity _ent = null;

    bool _picked = false, _clicked = false;

 

    public SelectableTransient(Entity ent)

    {

      _ent = ent;

    }

 

    protected override int SubSetAttributes(DrawableTraits traits)

    {

      // If the cursor is over the entity, make it colored

      // (whether it's red or yellow will depend on whether

      // there's a mouse-button click, too)

 

      traits.Color = (short)(_picked ? (_clicked ? 1 : 2) : 0);

 

      return (int)DrawableAttributes.None;

    }

 

    protected override void SubViewportDraw(ViewportDraw vd)

    {

      _ent.ViewportDraw(vd);

    }

 

    protected override bool SubWorldDraw(WorldDraw wd)

    {

      _ent.WorldDraw(wd);

 

      return true;

    }

 

    protected override void OnDeviceInput(DeviceInputEventArgs e)

    {

      bool redraw = false;

 

      if (e.Message == WM_LBUTTONDOWN)

      {

        _clicked = true;

 

        // If we're over the entity, absorb the click

        // (stops the window selection from happening)

 

        if (_picked)

        {

          e.Handled = true;

        }

        redraw = true;

      }

      else if (e.Message == WM_LBUTTONUP)

      {

        _clicked = false;

        redraw = true;

      }

 

      // Only update the graphics if things have changed

 

      if (redraw)

      {

        TransientManager.CurrentTransientManager.UpdateTransient(

          this, new IntegerCollection()

        );

 

        // Force a Windows message, as we may have absorbed the

        // click event (and this also helps when unclicking)

 

        ForceMessage();

      }

 

      base.OnDeviceInput(e);

    }

 

    private void ForceMessage()

    {

      // Set the cursor without ectually moving it - enough to

      // generate a Windows message

 

      System.Drawing.Point pt =

        System.Windows.Forms.Cursor.Position;

      System.Windows.Forms.Cursor.Position =

        new System.Drawing.Point(pt.X, pt.Y);

    }

 

    protected override void OnPointInput(PointInputEventArgs e)

    {

      bool wasPicked = _picked;

 

      _picked = false;

 

      Curve cv = _ent as Curve;

      if (cv != null)

      {

        Point3d pt =

          cv.GetClosestPointTo(e.Context.ComputedPoint, false);

        if (

          pt.DistanceTo(e.Context.ComputedPoint) <= 0.1

          // Tolerance.Global.EqualPoint is too small

        )

        {

          _picked = true;

        }

      }

 

      // Only update the graphics if things have changed

 

      if (_picked != wasPicked)

      {

        TransientManager.CurrentTransientManager.UpdateTransient(

          this, new IntegerCollection()

        );

      }

      base.OnPointInput(e);

    }

  }

 

  public class Commands

  {

    Line _ln = null;

    SelectableTransient _st = null;

 

    [CommandMethod("TRS")]

    public void TransientSelection()

    {

      // Create a line and pass it to the SelectableTransient

      // This makes cleaning up much more straightforward

 

      _ln = new Line(Point3d.Origin, new Point3d(10, 10, 0));

      _st = new SelectableTransient(_ln);

 

      // Tell AutoCAD to call into this transient's extended

      // protocol when appropriate

 

      Transient.CapturedDrawable = _st;

 

      // Go ahead and draw the transient

 

      TransientManager.CurrentTransientManager.AddTransient(

        _st, TransientDrawingMode.DirectShortTerm,

        128, new IntegerCollection()

      );

    }

 

    [CommandMethod("TRU")]

    public void RemoveTransientSelection()

    {

      // Removal is performed by setting to null

 

      Transient.CapturedDrawable = null;

 

      // Erase the transient graphics and dispose of the transient

 

      if (_st != null)

      {

        TransientManager.CurrentTransientManager.EraseTransient(

          _st,

          new IntegerCollection()

        );

        _st.Dispose();

        _st = null;

      }

 

      // And dispose of our line

 

      if (_ln != null)

      {

        _ln.Dispose();

        _ln = null;

      }

    }

  }

}

When you run the TRS command, you’ll see a line between the origin and the point 10,10. This is transient geometry, although not as we know it. ;-)

When you move your cursor across the line (to within 0.1 of a drawing unit, which I chose as the standard geometric tolerance was way too small to be usable when dealing with point input in this way) it should turn yellow:

And when you click the left-button of the mouse, it should turn red:

In itself this isn’t anything very impressive, but it provides the underpinnings to create something much more so. You’re essentially now able to create a transient gizmo that can react to mouse movement and button clicking, and in turn manipulate state in your AutoCAD session, in some way.

I’ve provided a TRU command to remove graphics and dispose of everything properly. You would probably want to take care of all this in your own application initialization and termination code, of course.

Incidentally there are optimisations that are probably worth making to this particular implementation: for instance, as this mechanism could end up being used by users throughout their typical drawing session – much in the way the ViewCube is – I’d suggest checking the cursor position against an area of the drawing that you hold in memory, to stop always checking it against the geometry itself (as I’ve done in this sample). I’m sure you’ll find out other ways to optimise the use of this mechanism as you work through the specifics of your own implementation.

Creating 3D street art using AutoCAD

As mentioned in this previous post, I was very keen to see how AutoCAD could be used to help streamline the process of generating what I’ve now found out can be classified as anamorphic street art. Leon Keer had mentioned that the technique dates back to Leonardo Da Vinci and – sure enough – Wikipedia agrees.

As part of my research, I found the original video that inspired my interest in Leon’s work, which should help put this post in context:

To make the process reasonably realistic – and to some degree replicate the approach Leon has taken in his projects – I managed to track down a free 3D model of a LEGO mini-figure. It’s available in various formats, but I chose to use FBX to bring it into AutoCAD.

If I were generating geometry for a real project, I’d probably create the scene using a product that can effectively manipulate instances of our mini-figure before bringing the full scene into AutoCAD (which presumably means Autodesk Maya, 3ds Max or MotionBuilder).

The workflow for creating the art was pretty standard, all things considered. Here’s a video of the process:

Here’s the process used in more detail:

1. Use FBXIMPORT to bring in the standard figure.
2. Use INSERT to create an instance of the imported block (having an elevation of –2.5 will make it look like it’s below the surface of the ground).
3. Use the ARRAY command to duplicate the block (I used a 3 x 6 grid).
4. Change the VISUALSTYLE to Realistic and make sure we’re viewing in perspective mode.
5. Use 3DORBIT to adjust the view to one you like.
6. Use FLATSHOT to generate a projection of the 3D geometry (without occluded lines) and place it anywhere.
7. Delete the flatshot block (you may want to get its name using LIST, first).
8. Set the UCS to the current View.
9. INSERT the flatshot block into this view at the middle of the 3D scene, then scale it to get it as close to the view as possible.
10. MOVE the inserted block so that it matches the view of the 3D geometry.
11. Place the flatshot block on its own layer (creating the layer using LAYER and changing the block’s layer property via PROPS or CHPROP).
12. You can use 3DORBIT to see that the block is really inserted on the view plane (and then UNDO or ZOOM P to get back to the 3D view).
13. Set the UCS back to World.
14. Use the custom SKEWSHOT command to generate a projected set of geometry from the flatshot block, adjusting the factor upwards or downwards to get a close fit.

And here’s the C# code defining the SKEWSHOT command:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.Runtime;

 

public class Commands

{

  [CommandMethod(

     "SKEWSHOT",

     CommandFlags.Modal | CommandFlags.UsePickSet

   )]

  static public void SkewShot()

  {

    Document doc = Application.DocumentManager.MdiActiveDocument;

    Editor ed = doc.Editor;

 

    // Select the entities to project (could also come from

    // pickfirst selection set)

 

    PromptSelectionOptions pso = new PromptSelectionOptions();

    pso.MessageForAdding = "Select entities to project";

    PromptSelectionResult psr = ed.GetSelection(pso);

 

    if (psr.Status != PromptStatus.OK)

      return;

 

    // Use an arbitrary factor to start with (this is the first

    // one that happened to work when I created my first drawing)

 

    double factor = 1.3;

    bool done = false;

 

    // Loop until the results are accepted

 

    while (!done)

    {

      // Ask the user to confirm the factor to use

 

      PromptDoubleOptions pdo =

        new PromptDoubleOptions("\nEnter factor");

      pdo.DefaultValue = factor;

      pdo.UseDefaultValue = true;

      pdo.AllowZero = false;

 

      PromptDoubleResult pdr = ed.GetDouble(pdo);

 

      if (pdr.Status != PromptStatus.OK)

        return;

 

      factor = pdr.Value;

 

      // Start a transaction, which will get aborted if we iterate

 

      Transaction tr = doc.TransactionManager.StartTransaction();

      using (tr)

      {

        // Project the contents of our selection set to the

        // ground plabe, using the current factor

 

        ProjectToGroundBasedOnFactor(tr, doc, psr.Value, factor);

 

        // Ask whether to accept or try again

 

        PromptKeywordOptions pko =

          new PromptKeywordOptions(

            "\nTry again with a different factor?"

          );

        pko.AllowNone = true;

        pko.Keywords.Add("Yes");

        pko.Keywords.Add("No");

        pko.Keywords.Default = "No";

 

        PromptResult pkr = ed.GetKeywords(pko);

 

        // Only commit the transaction if the results are accepted

 

        if (pkr.StringResult == "No")

        {

          done = true;

          tr.Commit();

        }

      }

    }

  }

 

  private static void ProjectToGroundBasedOnFactor(

    Transaction tr, Document doc, SelectionSet ss, double factor

  )

  {

    // We need to be able to write to the modelspace

 

    BlockTable bt =

      (BlockTable)tr.GetObject(

        doc.Database.BlockTableId, OpenMode.ForRead

      );

    BlockTableRecord btr =

      (BlockTableRecord)tr.GetObject(

        bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite

      );

 

    // Create our ground plane

 

    Plane pl = new Plane(Point3d.Origin, Vector3d.ZAxis);

 

    // Get the centre and direction of the current view

 

    Point3d vc = (Point3d)Application.GetSystemVariable("VIEWCTR");

    Point3d vd = (Point3d)Application.GetSystemVariable("VIEWDIR");

 

    // Use our factor to generate the direction for the projection

 

    Point3d viewcen =

      new Point3d(

        vc.X + (vd.X * factor),

        vc.Y + (vd.Y * factor),

        vc.Z + (vd.Z * factor)

      );

 

    // Call a recursive function for each object in the selection

    // set

 

    foreach (SelectedObject so in ss)

    {

      DBObject obj = tr.GetObject(so.ObjectId, OpenMode.ForRead);

      ProjectCurveOntoPlane(tr, btr, obj, pl, viewcen);

    }

  }

 

  private static void ProjectCurveOntoPlane(

    Transaction tr, BlockTableRecord btr, DBObject obj,

    Plane pl, Point3d viewCen

  )

  {

    // Currently support curve and block reference objects

 

    if (obj is BlockReference)

    {

      // For block references we explode and recurse

 

      BlockReference br = (BlockReference)obj;

      DBObjectCollection oc = new DBObjectCollection();

      br.Explode(oc);

      foreach (DBObject o in oc)

      {

        ProjectCurveOntoPlane(tr, btr, o, pl, viewCen);

      }

    }

    else if (obj is Curve)

    {

      // For curves we will project to the ground plane

 

      Curve cur = (Curve)obj;

 

      // Set the projection direction from center of the view to

      // the "mid" point of our curve (which is really the mid-point

      // between the start and end points, not necessarily the

      // geometric mid-point)

 

      Vector3d dir =

        (cur.StartPoint + ((cur.EndPoint - cur.StartPoint) / 2)) -

        viewCen;

 

      // Get the projected curve and add it to the modelspace

 

      Curve cur2 = cur.GetProjectedCurve(pl, dir);

 

      btr.AppendEntity(cur2);

      tr.AddNewlyCreatedDBObject(cur2, true);

    }

  }

}

The SKEWSHOT command takes a selection set of geometry and projects the curves it contains along the current view onto the ground plane (which clearly may be above or below the 3D model – on our case we’ve chosen it to be above, as our LEGO figures are supposed to be buried in the ground).

We’re actually projecting each curve along a live between its “mid” point (we’re actually taking the point directly between its start and its end – not necessarily it’s geometric mid-point) and the camera. As each curve is projected differently they may end up not touching, but they should nonetheless provide a good enough guide for the drawing’s outline.

Also, each view is a little different, so I’ve added an adjustable factor that can be used to tweak the results. The code works on a loop – with a transaction used for each pass that only gets committed when the results are acceptable – to make it easier to make repeated adjustments.

Here’s the drawing file (saved as an AutoCAD 2013 .dwg – just post a comment if you’d like a previous version to be saved off and posted) I created while recording the above video, if you’d like to take a look at it. It’s clear there’s a big gap between these results and a work of art. :-) This is really trying to demonstrate the principle: more work would be needed to make sure the camera position is at an appropriate point above the ground to give a genuine 3D effect, as well as generating a 3D model that’s aesthetically pleasing and then an effective 2D interpretation of it. CAD is clearly never going to replace art, but it can hopefully take some of the pain out of it. ;-)

I’m hoping to find the time to give this a try over the coming weeks, although obviously on a much smaller scale than Leon & co.

Update:

I’ve just seen Leon has posted a timelapse video of the LEGOLAND Windsor project. You can see my family flash past at around the 2m26s mark. :-)

Chamfering the selected edge of an AutoCAD solid using .NET

Another piece of code culled from an email from Balaji Ramamoorthy, from DevTech India. I did a little refactoring and formatting, to fit the blog. Thanks, Balaji! :-)

The below C# code demonstrates how to use Solid3d.ChamferEdges() with a user-selected edge and face. Balaji has also provided code to determine the edge and face programmatically – without the user needing to select anything – using the Brep API. I expect to show that approach in a subsequent post.

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using System;

 

namespace SolidEditing

{

  public class Commands

  {

    [CommandMethod("EC")]

    public void EdgeChamfer()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

 

      // Select an edge

 

      PromptSelectionOptions pso =

        new PromptSelectionOptions();

      pso.MessageForAdding = "\nSelect edge to chamfer";

      pso.SingleOnly = true;

      pso.ForceSubSelections = true;

 

      PromptSelectionResult psrEdge = ed.GetSelection(pso);

 

      if (psrEdge.Status != PromptStatus.OK)

        return;

 

      // Select a face

 

      pso.MessageForAdding =

        "\nSelect the face to which the edge belongs";

      pso.SinglePickInSpace = true;

 

      PromptSelectionResult psrFace = ed.GetSelection(pso);

 

      if (psrFace.Status != PromptStatus.OK)

        return;

 

      try

      {

        Transaction tr =

          db.TransactionManager.StartTransaction();

        using (tr)

        {

          ObjectId edgeSolId, faceSolId;

 

          // Get the subentity Id for the edge and the face

 

          SubentityId edgeId =

            GetSubentity(

              ed, tr, psrEdge.Value, SubentityType.Edge,

              out edgeSolId

            );

 

          SubentityId faceId =

            GetSubentity(

              ed, tr, psrFace.Value, SubentityType.Face,

              out faceSolId

            );

 

          // We also have the Ids of their containing solids,

          // so we can check they belong to the same one

 

          if (edgeSolId == faceSolId && edgeSolId != ObjectId.Null)

          {

            Solid3d solid =

              tr.GetObject(edgeSolId, OpenMode.ForWrite)

              as Solid3d;

            if (solid != null)

            {

              // Here's where we actually chamfer the edge

              // with hard-coded values

 

              SubentityId[] edgeIds =

                new SubentityId[] { edgeId };

              solid.ChamferEdges(edgeIds, faceId, 0.5, 1.0);

            }

            tr.Commit();

          }

        }

      }

      catch (Autodesk.AutoCAD.Runtime.Exception ex)

      {

        ed.WriteMessage(ex.Message);

      }

    }

 

    public static SubentityId GetSubentity(

      Editor ed, Transaction tr, SelectionSet ss,

      SubentityType type, out ObjectId solId

    )

    {

      SubentityId retId = new SubentityId();

 

      // Should have only one object in the array

 

      SelectedObject so = ss[0];

 

      // We set our out parameter to the owning solid's ObjectId

 

      solId = so.ObjectId;

 

      // Access the solid via the transaction passed in

 

      Solid3d solid =

        tr.GetObject(so.ObjectId, OpenMode.ForRead)

        as Solid3d;

 

      // Get its subentities

 

      SelectedSubObject[] sso = so.GetSubentities();

 

      // Get their first subentity's type

 

      SubentityType subentityType =

        sso[0].FullSubentityPath.SubentId.Type;

 

      // See if it's of the type we want

 

      if (subentityType == type)

      {

        retId = sso[0].FullSubentityPath.SubentId;

      }

      else

      {

        ed.WriteMessage(

          "\nInvalid Subentity Type: {0}, " +

          "Expecting a {1} to be selected.\n",

          subentityType, type.ToString()

        );

      }

 

      return retId;

    }

  }

}

We’ll use a simple box to test the code:

Here’s what happens when we run the EC command to chamfer each of the top edges (selecting the top face, each time):

Creating a legend of AutoCAD drawings using .NET

This interesting question came up in our discussion forums:

Does anyone have a routine that will insert all the drawings from a single folder into one drawing to create a legend sheet? I'm trying to document the company's various blocks and details for dissemination amongst several offices.

The simplest – and most elegant, in my opinion – approach for addressing this requirement is via the Table object, which allows you to include block thumbnails in each of its cells. So we would need to import the various drawings into the current drawing as blocks, and then point the various cells of the table object at each of them, in turn. Thankfully I could borrow a good amount of the code to do this from these previous posts.

Here’s the C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Windows;

using System.IO;

using System.Linq;

 

namespace MythsAndLegends

{

  public class Commands

  {

    [CommandMethod("LEGEND")]

    public void CreateLegend()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

 

      // Ask the user to select the drawings to list in the table

 

      OpenFileDialog ofd =

        new OpenFileDialog(

          "Select drawings to add to legend",

          null,

          "dwg",

          "DrawingsToImport",

          OpenFileDialog.OpenFileDialogFlags.AllowMultiple

        );

 

      System.Windows.Forms.DialogResult dr = ofd.ShowDialog();

 

      if (dr != System.Windows.Forms.DialogResult.OK)

        return;

 

      // Get the list of filenames and say how many were selected

 

      string[] names = ofd.GetFilenames();

      ed.WriteMessage(

        "\n{0} files selected.", names.Length

      );

 

      // If we have some selected, we'll create a table

 

      if (names.Length > 0)

      {

        int numRows, numCols;

 

        // If only one was selected, we know the table will

        // be 1x1

 

        if (names.Length == 1)

        {

          numRows = 1;

          numCols = 1;

        }

        else

        {

          // Otherwise we prompt for the number of columns

 

          PromptIntegerOptions opts =

            new PromptIntegerOptions(

              "\nEnter number of columns: "

            );

 

          opts.LowerLimit = 1;

          opts.UpperLimit = names.Length;

          opts.DefaultValue = 1;

          opts.UseDefaultValue = true;

 

          PromptIntegerResult pir = ed.GetInteger(opts);

 

          if (pir.Status != PromptStatus.OK)

            return;

 

          // Get whether to start at the top or the bottom

 

          PromptKeywordOptions pko =

            new PromptKeywordOptions(

              "\nPopulate from the top or from the bottom?"

            );

          pko.AllowNone = true;

          pko.Keywords.Add("Top");

          pko.Keywords.Add("Bottom");

          pko.Keywords.Default = "Top";

 

          PromptResult pkr = ed.GetKeywords(pko);

 

          bool fromTop = (pkr.StringResult == "Top");

 

          // Get whether to start at the top or the bottom

 

          pko =

            new PromptKeywordOptions(

              "\nList alphabetically or in selected order?"

            );

          pko.AllowNone = true;

          pko.Keywords.Add("Alphabetically");

          pko.Keywords.Add("Selected");

          pko.Keywords.Default = "Alphabetically";

 

          pkr = ed.GetKeywords(pko);

 

          bool sort = (pkr.StringResult == "Alphabetically");

 

          // And the insertion point of the table

 

          PromptPointResult pr =

            ed.GetPoint("\nEnter table insertion point: ");

 

          if (pr.Status == PromptStatus.OK)

          {

            Transaction tr =

              doc.TransactionManager.StartTransaction();

 

            using (tr)

            {

              // Use constants for the cell dimensions

 

              const int cellWidth = 3;

              const int cellHeight = 3;

 

              // Create the table

 

              Table tb = new Table();

              tb.TableStyle = db.Tablestyle;

 

              // We can calculate the number of rows based on

              // the number of cells and the number of columns

 

              numCols = pir.Value;

              numRows = (names.Length / numCols) + 1;

 

              // We'll add in our custom columns and rows

 

              if (numCols > 0)

              {

                tb.InsertColumns(1, cellWidth, numCols);

              }

              if (numRows > 0)

              {

                tb.InsertRows(1, cellHeight, numRows);

              }

 

              // And then delete the original row/column

              // that comes with the blank table

 

              tb.DeleteRows(0, 1);

              tb.DeleteColumns(0, 1);

 

              tb.Position = pr.Value;

 

              if (sort)

              {

                names = names.OrderBy(x => x).ToArray<string>();

              }

 

              // Loop through the names, adding them to the table

 

              for (int i = 0; i < names.Length; i++)

              {

                string blockName = "";

 

                try

                {

                  // Use a Database to insert a block for each

                  // drawing into the current drawing

 

                  using (Database src = new Database(false, true))

                  {

                    // First we read in the DWG

 

                    src.ReadDwgFile(

                      names[i], FileShare.Read, true, ""

                    );

 

                    // Take the name of the file without the

                    // extension

 

                    blockName =

                      Path.GetFileNameWithoutExtension(names[i]);

 

                    // Check whether it works as a symbol table

                    // name (will thrown an exception if not)

 

                    SymbolUtilityServices.ValidateSymbolName(

                      blockName, false

                    );

 

                    // Insert our drawing as a block (which

                    // will take the modelspace)

 

                    ObjectId blockId =

                      db.Insert(blockName, src, false);

 

                    // Calculate the row and column for this item

                    // If from the top: we just divide by the

                    // number of columns to get the row

                    // If from the bottom, subtract from

                    // the total rows

 

                    int row =

                      (fromTop ?

                        i / numCols :

                        numRows - (i / numCols + 1)

                      );

 

                    // The column is just the modulus remainder

 

                    int col = i % numCols;

 

                    // Insert the block as the contents of our cell

 

                    Cell cell = tb.Cells[row, col];

                    cell.Contents.InsertAt(0);

                    cell.Contents[0].BlockTableRecordId =

                       blockId;

                  }

                }

                catch (System.Exception ex)

                {

                  ed.WriteMessage(

                    "\nCould not add \"{0}\": {1}",

                    blockName, ex.Message

                  );

                }

              }

              tb.GenerateLayout();

 

              // Finally we add our table to modelspace

 

              BlockTable bt =

                (BlockTable)tr.GetObject(

                  doc.Database.BlockTableId,

                  OpenMode.ForRead

                );

 

              BlockTableRecord btr =

                (BlockTableRecord)tr.GetObject(

                  bt[BlockTableRecord.ModelSpace],

                  OpenMode.ForWrite

                );

              btr.AppendEntity(tb);

              tr.AddNewlyCreatedDBObject(tb, true);

              tr.Commit();

            }

          }

        }

      }

    }

  }

}

When we run the LEGEND command, we get asked to select some drawings:

We then get prompted with the number of drawings selected and get asked to provide some additional information to determine how the table gets created. We’ll run the command twice, selecting the same set of AutoCAD sample drawings but using 3 and 4 columns, populating the two tables from the top and the bottom respectively.

Command: LEGEND

13 files selected.

Enter number of columns <1>: 3

Populate from the top or from the bottom? [Top/Bottom] <Top>: Top

List alphabetically or in selected order? [Alphabetically/Selected]

<Alphabetically>: Alphabetically

Enter table insertion point:

 

[Dump of block imports deleted...]

 

Command: LEGEND

13 files selected.

Enter number of columns <1>: 4

Populate from the top or from the bottom? [Top/Bottom] <Top>: Bottom

List alphabetically or in selected order? [Alphabetically/Selected]

<Alphabetically>: Alphabetically

Enter table insertion point:

 

[Dump of block imports deleted...]

We can see that the tables contain the same order of blocks, but the first is wider and was populated from the top-left rather than the bottom-left: