Through the Interface

Using AutoCAD’s Bindable Object Layer to change the current view using .NET

After looking at how the Bindable Object Layer (BOL) in AutoCAD might be used to get information about the current drawing, in today’s post we’re going to see how it can also be used to manipulate that data (in a fairly limited, albeit useful, way).

But first, let’s talk a bit about the origins of the BOL. It was first introduced as an architectural feature of AutoCAD when we were looking at delivering AutoCAD for Mac. It’s common, these days, for programming frameworks to provide some kind of data-binding facility to simplify the creation of UIs: both WPF and Cocoa have data-binding capabilities, for instance, that allow programmers to point collection-friendly UI widgets – such as list- and combo-boxes – at core data collections containing the information they wish to present to the user.

The BOL was our (primarily internal) effort to create a cross-platform, abstract information layer that could be bound via WPF on Windows and Cocoa on OS X to present the UI most appropriate to the respective platforms. Some work was needed to expose the core layer on each platform, but the underlying C++ implementation – contained within AcCore – is shared across platforms.

For instance, much of the information regarding the state of the current drawing – such as the current layer, linetype, dimension/table/text/visual (etc.) style – is providing to AutoCAD’s ribbon by the BOL. The BOL provides the most recent information – it gets updated as the drawing changes and even as the active drawing changes – so that the UI can simply update whenever changes propagate through the BOL.

Which actually makes the BOL quite a powerful abstraction for use programmatically, too. While it’s not directly possible to add items to the BOL and have them appear in the drawing, it is possible to use the BOL to change the “current” item in a collection, and also to use the BOL to find out when modifications have been made to its various collections.

The BOL can therefore be used to change the current Visual Style, the current layer, or – as we show in the post – the current named view.

And here’s the C# code that does so:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Windows.Data;

using System.Collections.Generic;

 

public class BolAccess

{

  [CommandMethod("CHGVW")]

  static public void ChangeViewViaBol()

  {

    Editor ed =

      Application.DocumentManager.MdiActiveDocument.Editor;

 

    // Get our set of named views

 

    var views = Application.UIBindings.Collections.NamedViews;

    if (views.Count == 0)

    {

      ed.WriteMessage("\nNo named views available.");

    }

    else

    {

      ed.WriteMessage("\nNamed views available:");

 

      // Create a list in which to store the names of our views

 

      List<string> viewNames = new List<string>(views.Count);

 

      // Loop through the view list, populating our list of names

      // and printing each one for later selection

 

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

      {

        // Add a dummy item - will be replaced via the index later

 

        viewNames.Add("");

 

        var desc = views[i];

 

        // Get the collection's property descriptors

 

        var props = desc.GetProperties();

 

        // Set our view name as the value of each "Name" property

        // (do so by index, just to make sure we're keeping in sync

        // with the values in the views collection)

 

        viewNames[i] = (string)props["Name"].GetValue(desc);

 

        // Print the name along with the 1-based index

 

        ed.WriteMessage("\n {0} {1}", i+1, viewNames[i]);

      }

 

      // Ask the user to select the view based on the index

 

      PromptIntegerOptions opts =

        new PromptIntegerOptions("\nEnter number of view: ");

 

      opts.LowerLimit = 1;

      opts.UpperLimit = views.Count;

 

      PromptIntegerResult pir = ed.GetInteger(opts);

      if (pir.Status == PromptStatus.OK)

      {

        // Simply set our current item to the one selected

 

        views.CurrentItem = views[pir.Value - 1];

      }

    }

  }

}

When we run the CHGVW command inside the “visualization_-_condominium_with_skylight.dwg” sample drawing, we see we can use it to navigate easily between the various named views:

Dumping data from AutoCAD’s Bindable Object Layer using .NET

Some time ago, I posted code that used the Autodesk.AutoCAD.Windows.Data namespace to list the hatch patterns in the current drawing.

Fenton Webb posted a follow-up on the AutoCAD DevBlog that took this further, extracting additional data from AutoCAD and using it to populate an Excel spreadsheet. Within that post, Fenton showed the technique required to access and iterate across other data collections – something I hadn’t managed to do when creating my original post.

Rather than repeat exactly what Fenton has put together – which is really nice, do take a look at it – I’m just taking a small amount of Fenton’s code and replicating it here – along with some code using reflection, to keep the code succinct – to dump some data to the command-line:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Windows.Data;

 

public class DataStuff

{

  [CommandMethod("HPS")]

  static public void GetHatchPatterns()

  {

    Editor ed =

      Application.DocumentManager.MdiActiveDocument.Editor;

    foreach (

      string str in HatchPatterns.Instance.AllPatterns)

      ed.WriteMessage("\n" + str);

  }

 

  [CommandMethod("DUMPBOL")]

  static public void DumpBindableObjects()

  {

    Editor ed =

      Application.DocumentManager.MdiActiveDocument.Editor;

 

    // Get our set of collections

 

    var cols = Application.UIBindings.Collections;

 

    // Use reflection to determine the properties of type

    // DataItemCollection (could extend to support others, too)

 

    var t = cols.GetType();

    var tprops = t.GetProperties();

    foreach (var tprop in tprops)

    {

      // Make sure we only deal with DataItemCollection properties

      // that do not take any parameters

 

      if (

        tprop.PropertyType == typeof(DataItemCollection) &&

        tprop.GetGetMethod().GetParameters().Length == 0

      )

      {

        // Dump our the property name first

 

        ed.WriteMessage("\n{0}:", tprop.Name);

 

        // Get the collection itself and iterate through it

 

        var col = (DataItemCollection)tprop.GetValue(cols, null);

        foreach (var desc in col)

        {

          // Get the collection's property descriptors

 

          var props = desc.GetProperties();

          try

          {

            // Dump the value of each "Name" property

 

            ed.WriteMessage(

              " \"{0}\"", props["Name"].GetValue(desc)

            );

          }

          catch

          {

            // Just in case no "Name" property exists, we try-catch

          }

        }

      }

    }

  }

}

The main trick is actually to get data from the BOL – AutoCAD’s Bindable Object Layer – via the various properties inside Application.UIBindings.Collections.

We’re using reflection to avoid hardcoding the various properties we want to access: we just loop through the main collection set’s properties, looking for any of type DataItemCollection. We might also extend the code to support other property types – such as EnumItemCollection – but that’s left as an exercise for the reader.

Here’s the command-line output we see in a blank drawing when we run the DUMPBOL command:

Command: DUMPBOL

UcsPlanes:

PlotStyles:

RenderPresets: "" "" "" "" ""

TableCellStyles:

NamedViews:

Linetypes: "ByBlock" "ByLayer" "Continuous" "PHANTOM2"

LayerFilters: "All" "All Used Layers" "Unreconciled New Layers" "Viewport Overrides"

LayerStates:

Layers: "0"

VisualStyles: "2D Wireframe" "Conceptual" "Hidden" "Realistic" "Shaded" "Shaded with edges" "Shades of Gray" "Sketchy" "Wireframe" "X-Ray"

TextStyles: "Standard" "Annotative"

DimensionStyles: "Standard" "Annotative"

DetailViewStyles: "Imperial24"

SectionViewStyles: "Imperial24"

MleaderStyles: "Annotative" "Standard"

TableStyles: "Standard"

Getting the list of hatch patterns available in the current AutoCAD drawing using .NET

This post was inspired by an email I saw from Philippe Leefsma, from DevTech EMEA, which made use of the Autodesk.AutoCAD.Windows.Data namespace – something I didn’t even know existed.

The specific example Philippe showed was how to access the list of hatch patterns available in the current drawing without iterating through the relevant dictionary in the named objects dictionary.

Here’s Philippe’s C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Windows.Data;

 

public class DataStuff

{

  [CommandMethod("HPS")]

  static public void GetHatchPatterns()

  {

    Editor ed =

      Application.DocumentManager.MdiActiveDocument.Editor;

    foreach (

      string str in HatchPatterns.Instance.AllPatterns)

      ed.WriteMessage("\n" + str);

  }

}

When we run it, we see the following output at the command-line:

Command: HPS

SOLID

ANGLE

ANSI31

ANSI32

ANSI33

ANSI34

ANSI35

ANSI36

ANSI37

ANSI38

AR-B816

AR-B816C

AR-B88

AR-BRELM

AR-BRSTD

AR-CONC

AR-HBONE

AR-PARQ1

AR-RROOF

AR-RSHKE

AR-SAND

BOX

BRASS

BRICK

BRSTONE

CLAY

CORK

CROSS

DASH

DOLMIT

DOTS

EARTH

ESCHER

FLEX

GOST_GLASS

GOST_GROUND

GOST_WOOD

GR_LINEAR

GR_CYLIN

GR_INVCYL

GR_SPHER

GR_HEMISP

GR_CURVED

GR_INVSPH

GR_INVHEM

GR_INVCUR

GRASS

GRATE

GRAVEL

HEX

HONEY

HOUND

INSUL

ACAD_ISO02W100

ACAD_ISO03W100

ACAD_ISO04W100

ACAD_ISO05W100

ACAD_ISO06W100

ACAD_ISO07W100

ACAD_ISO08W100

ACAD_ISO09W100

ACAD_ISO10W100

ACAD_ISO11W100

ACAD_ISO12W100

ACAD_ISO13W100

ACAD_ISO14W100

ACAD_ISO15W100

LINE

MUDST

NET

NET3

PLAST

PLASTI

SACNCR

SQUARE

STARS

STEEL

SWAMP

TRANS

TRIANG

ZIGZAG

USER

I was curious about this namespace and so asked around to find out more about its origins. Apparently it was introduced to provide simplified access to data that needs to be displayed in the AutoCAD user interface: we expose this data through Autodesk.AutoCAD.Windows.Data to make it simpler to implement the ribbon without having to iterate database objects there directly. What’s nice is the data changes when the connected database does: whether relevant items are added to, edited in or removed from the database, or the user changes the currently active drawing in the editor, the data made accessible is adjusted accordingly.

This capability is known internally as the BOL or Bindable Object Layer. Cool stuff.

At this stage, I didn’t find a way to access other data from this namespace: HatchPatterns is the only class with a static Instance property that provides access to it. There is a very interesting DataBindings class, that appears to provide access to the data in the rest of the namespace, but I so far have been unable to find a way to instantiate (or retrieve an existing instance of it).

Setting the current visual style in AutoCAD using .NET

A quick one to end the week, as I really need to start packing for AU. :-)

Thanks to Augusto Gonçalves, from DevTech Americas, for pointing out this DevNote on the ADN site in a recent email to an ADN member.

The below code shows the steps to set the current visual style to “realistic” in AutoCAD. As with many AutoCAD features, you can also set the current visual style by sending commands to the command-line, but then why do something in 3 lines of code when you can do it in 40? ;-) Seriously, there are some advantages to this approach – such as not polluting the command history, for instance – but that’s really a decision for individual developers to make.

Here’s the C# code defining the SVS command:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

 

namespace VisualStyles

{

  public class Commands

  {

    [CommandMethod("SVS")]

    static public void SetRealisticVisualStyle()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

      Database db = doc.Database;

 

      Transaction tr =

        db.TransactionManager.StartTransaction();

      using (tr)

      {

        ViewportTable vt =

          (ViewportTable)tr.GetObject(

            db.ViewportTableId, OpenMode.ForRead

          );

        ViewportTableRecord vtr =

          (ViewportTableRecord)tr.GetObject(

            vt["*Active"], OpenMode.ForWrite

          );

        DBDictionary dict =

          (DBDictionary)tr.GetObject(

            db.VisualStyleDictionaryId, OpenMode.ForRead

          );

        vtr.VisualStyleId = dict.GetAt("Realistic");

 

        tr.Commit();

      }

      ed.UpdateTiledViewportsFromDatabase();

    }

  }

}

Here’s a simple indication of the SVS command working. The Visual Styles ribbon panel before…

… and after execution of the SVS command:

That’s it, for now: I’ll hopefully post a few updates next week from AU 2011.

AutoCAD .NET Training DevTV Session 5: Dictionaries, Containers, Type Identification, Casting

This post was queued up for Friday, but a technical issue (i.e. probably user error) prevented it from going out.

So here we are on Sunday, instead, for another installment of Wayne Brill’s AutoCAD .NET training DevTV series (to complement those from previous weeks). Today’s session is focused on working with dictionaries and other types of container, as well as using runtime type identification and casting.

This series of DevTV sessions is a companion for the new AutoCAD .NET training material available from the AutoCAD .NET Developer Center.

Enjoy! :-)

Exploding AutoCAD objects using .NET

Time to go back to basics. I realised recently – on receiving this comment – that I hadn’t specifically covered the nature of Entity.Explode() in a post (even if it’s been used in a few of them, over the years).

Entity.Explode() is one of those tricky methods: it’s actually a faux-ami with the AutoCAD command of the same name, in a very similar way to Database.Purge(). The way in which Explode() and Purge() differ from their “equivalent” commands is that they’re non-destructive: they don’t actually result in a change to the AutoCAD drawing database. Explode() populates a DBObjectCollection with the results of the explode operation, and it’s then up to the caller of the function to add them to the appropriate location (typically the current – i.e. model- or paper- – space). Purge() checks a list of objects for ones that can safely be erased, and then it’s up to the caller of the function to do so.

So there is some occasional – and understandable – confusion around Explode() or Purge() not working as expected.

Here’s a simple approach to mimicking the behaviour of the EXPLODE command programmatically: after calling Entity.Explode() on each selected entity, we optionally erase the original entities and add the results of the Explode() to the drawing.

There’s a lot this code doesn’t do – such as check for entities that did not actually generate any exploded results (and so probably shouldn’t be erased) or output some feedback on what is happening to the command-line – but the principle should be clear enough.

Here’s the C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

 

namespace Explosion

{

  public class Commands

  {

    [CommandMethod("EXP", CommandFlags.UsePickSet)]

    public void ExplodeEntities()

    {

      Document doc =

          Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

 

      // Ask user to select entities

 

      PromptSelectionOptions pso =

        new PromptSelectionOptions();

      pso.MessageForAdding = "\nSelect objects to explode: ";

      pso.AllowDuplicates = false;

      pso.AllowSubSelections = true;

      pso.RejectObjectsFromNonCurrentSpace = true;

      pso.RejectObjectsOnLockedLayers = false;

 

      PromptSelectionResult psr = ed.GetSelection(pso);

      if (psr.Status != PromptStatus.OK)

        return;

 

      // Check whether to erase the original(s)

 

      bool eraseOrig = false;

 

      if (psr.Value.Count > 0)

      {

        PromptKeywordOptions pko =

          new PromptKeywordOptions("\nErase original objects?");

        pko.AllowNone = true;

        pko.Keywords.Add("Yes");

        pko.Keywords.Add("No");

        pko.Keywords.Default = "No";

 

        PromptResult pkr = ed.GetKeywords(pko);

        if (pkr.Status != PromptStatus.OK)

          return;

 

        eraseOrig = (pkr.StringResult == "Yes");

      }

 

      Transaction tr =

        db.TransactionManager.StartTransaction();

      using (tr)

      {

        // Collect our exploded objects in a single collection

 

        DBObjectCollection objs = new DBObjectCollection();

 

        // Loop through the selected objects

 

        foreach (SelectedObject so in psr.Value)

        {

          // Open one at a time

 

          Entity ent =

            (Entity)tr.GetObject(

              so.ObjectId,

              OpenMode.ForRead

            );

 

          // Explode the object into our collection

 

          ent.Explode(objs);

 

          // Erase the original, if requested

 

          if (eraseOrig)

          {

            ent.UpgradeOpen();

            ent.Erase();

          }

        }

 

        // Now open the current space in order to

        // add our resultant objects

 

        BlockTableRecord btr =

          (BlockTableRecord)tr.GetObject(

            db.CurrentSpaceId,

            OpenMode.ForWrite

          );

 

        // Add each one of them to the current space

        // and to the transaction

 

        foreach (DBObject obj in objs)

        {

          Entity ent = (Entity)obj;

          btr.AppendEntity(ent);

          tr.AddNewlyCreatedDBObject(ent, true);

        }

 

        // And then we commit

 

        tr.Commit();

      }

    }

  }

} 

The results of calling the EXP command should be obvious enough – and do not result in anything very visually stimulating – so I’ll finish the post here.

Customizing ScriptPro 2.0 to process drawings not present in the AutoCAD editor

It’s time to wrap up the series on batch-reporting Registered Application IDs. For reference, here’s how we got to where we are today:

1. Implement a command to collect RegAppId information for the active document
2. Extend this command to work on a drawing not loaded in the editor
3. Save our RegAppId information to some persistent location (XML)
   • Transform the resulting XML file to HTML using XSLT
4. Create a modified version of ScriptPro 2.0 (one of our Plugins of the Month) to call our command without opening the drawing

The broader point of today’s post – other than simply to deliver on step 4, above – is to demonstrate that there are definitely simple options when it comes to architecting and building your own batch-processing tool. It’s quite possible that ScriptPro 2.0 does what you want, out of the box, but in our case it does not: we do not want to load a drawing into the AutoCAD editor to process it, we want to run a custom command to load drawings in side databases in order to process them more quickly.

But as the full source code for ScriptPro 2.0 is available on Autodesk Labs, it’s a simple matter of editing it for our own purposes. I won’t go into great detail on the changes that were needed – most of which were cosmetic in nature – but I will list a few areas:

• Changed the name of the application from ScriptPro 2.0 to RegAppReport
• Stripped down the UI of the main dialog
  • Reduced unwanted items from the ribbon (load SCP, for instance)
  • Removed the script selection box and associated code
  • I didn’t bother changing the options dialog, at all, but I did change the load/save of the drawing lists not to include that information
• Removed the code to open the selected document in the AutoCAD editor
• Customized the code to call our XRA command – rather than SCRIPT – passing in the DWG we want to process via the command-line
• Added some code to copy the file placed at C:\RegAppData.xml to the executable location, where our XSLT resides
  • I also decided to back up the previous contents of this file, in case they were needed
  • We could also have specified the XML as an argument to the command, but felt it less disruptive (in terms of changes to the previous implementation) to do it this way
• We give the option of automatically launching the XML report (rendered to HTML, of course) after processing

It should be noted that the code developed in the previous posts, defining the XRA command, should be built into a plugin and set up to load automatically into AutoCAD at startup or when the XRA command is called (you can, of course, set this up programmatically).

Here are the C# source project and executable files for the modified ScriptPro 2.0 application.

Here’s the application in action…

And finally the results…

It’s altogether possible to extend this application to actually – even selectively – purge RegAppIds from drawings, but that’s being left as an exercise for the reader.

Transforming a list of RegAppIds from XML to HTML using XSLT

As raised as a possibility at the end of the last post, I did choose to throw together a quick XSLT stylesheet to generate an HTML report of the XML data created by our XRA command.

To enable this I did make a few changes to our command implementation, which we’ll take a look at first.

Here’s the updated C# code, with new/modified lines in red (and here’s the updated source file):

    1 using Autodesk.AutoCAD.ApplicationServices;

    2 using Autodesk.AutoCAD.DatabaseServices;

    3 using Autodesk.AutoCAD.EditorInput;

    4 using Autodesk.AutoCAD.Runtime;

    5 using System.Collections.Generic;

    6 using System.Text;

    7 using System.Xml;

    8 using System.Xml.Serialization;

    9 using System.IO;

   10 using System;

   11 

   12 namespace XrefRegApps

   13 {

   14   [XmlRoot("RegAppData")]

   15   public class RegAppData

   16   {

   17     // The name of our drawing

   18 

   19     private string _name;

   20 

   21     [XmlAttribute("Name")]

   22     public string Name

   23     {

   24       get { return _name; }

   25       set { _name = value; }

   26     }

   27 

   28     // The location of our drawing

   29 

   30     private string _dwg;

   31 

   32     [XmlAttribute("File")]

   33     public string File

   34     {

   35       get { return _dwg; }

   36       set { _dwg = value; }

   37     }

   38 

   39     private string _dwgVersion;

   40 

   41     [XmlAttribute("DwgVersion")]

   42     public string DwgVersion

   43     {

   44       get { return _dwgVersion; }

   45       set { _dwgVersion = value; }

   46     }

   47 

   48     // The list of our drawing's Registered Application IDs

   49 

   50     private List<string> _regAppIds = new List<string>();

   51 

   52     [XmlArrayItem("RegAppId")]

   53     public List<string> RegAppIds

   54     {

   55       get { return _regAppIds; }

   56       set { _regAppIds = value; }

   57     }

   58 

   59     public void AddRegAppId(string id)

   60     {

   61       if (!_regAppIds.Contains(id))

   62         _regAppIds.Add(id);

   63     }

   64   }

   65 

   66   public class Commands

   67   {

   68     private const string regAppDataXml = "c:\\RegAppData.xml";

   69 

   70     private void SerializeRegAppData(

   71       Dictionary<string, RegAppData> dict

   72     )

   73     {

   74       if (dict.Count > 0)

   75       {

   76         // No direct way to serialize a dictionary to XML,

   77         // so we'll create a list from it and serialize that

   78 

   79         List<RegAppData> regData =

   80           new List<RegAppData>(dict.Count);

   81         foreach (KeyValuePair<string, RegAppData> kv in dict)

   82         {

   83           regData.Add(kv.Value);

   84         }

   85 

   86         // Serialize our list to the specified XML file

   87 

   88         XmlSerializer xs =

   89           new XmlSerializer(typeof(List<RegAppData>));

   90         XmlTextWriter xw =

   91           new XmlTextWriter(regAppDataXml, Encoding.UTF8);

   92         xw.WriteProcessingInstruction(

   93           "xml-stylesheet",

   94           "type=\"text/xsl\" href=\"RegAppData.xslt\""

   95         );

   96         xs.Serialize(xw, regData);

   97         xw.Close();

   98       }

   99     }

  100 

  101     // Read and return the previous Registered Application data

  102     // from our stored XML file

  103 

  104     private Dictionary<string, RegAppData>

  105       DeserializeRegAppData()

  106     {

  107       if (File.Exists(regAppDataXml))

  108       {

  109         XmlSerializer xs =

  110           new XmlSerializer(typeof(List<RegAppData>));

  111         XmlTextReader xr = new XmlTextReader(regAppDataXml);

  112         if (xs.CanDeserialize(xr))

  113         {

  114           // No direct way to serialize a dictionary to XML,

  115           // so we'll read a list and populate a dictionary

  116           // from it

  117 

  118           List<RegAppData> regData =

  119             (List<RegAppData>)xs.Deserialize(xr);

  120           xr.Close();

  121           Dictionary<string, RegAppData> dict =

  122             new Dictionary<string, RegAppData>();

  123           foreach (RegAppData rad in regData)

  124           {

  125             dict.Add(rad.File, rad);

  126           }

  127           return dict;

  128         }

  129       }

  130       return new Dictionary<string, RegAppData>();

  131     }

  132 

  133     [CommandMethod("XRA")]

  134     public void ExternalReferenceRegisteredApps()

  135     {

  136       Document doc =

  137           Application.DocumentManager.MdiActiveDocument;

  138       Database db = doc.Database;

  139       Editor ed = doc.Editor;

  140 

  141       // Prompt the user for the path to a DWG to test

  142 

  143       PromptStringOptions pso =

  144         new PromptStringOptions(

  145           "\nEnter path to root drawing file: "

  146         );

  147       pso.AllowSpaces = true;

  148       PromptResult pr = ed.GetString(pso);

  149       if (pr.Status != PromptStatus.OK)

  150         return;

  151 

  152       if (!File.Exists(pr.StringResult))

  153       {

  154         ed.WriteMessage("\nFile does not exist.");

  155         return;

  156       }

  157 

  158       try

  159       {

  160         // We start by reading any existing RegApp data

  161         // from XML

  162 

  163         Dictionary<string, RegAppData> regData =

  164           DeserializeRegAppData();

  165 

  166         // Load the DWG into a side database

  167 

  168         Database mainDb = new Database(false, true);

  169         using (mainDb)

  170         {

  171           mainDb.ReadDwgFile(

  172             pr.StringResult,

  173             FileOpenMode.OpenForReadAndAllShare,

  174             true,

  175             null

  176           );

  177 

  178           // We need an additional step to resolve Xrefs

  179 

  180           mainDb.ResolveXrefs(false, false);

  181 

  182           // Get the XrefGraph for the specified database

  183 

  184           XrefGraph xg = mainDb.GetHostDwgXrefGraph(true);

  185 

  186           // Loop through the nodes in the graph

  187 

  188           for (int i = 0; i < xg.NumNodes; i++)

  189           {

  190             // Get each node and check its status

  191 

  192             XrefGraphNode xgn = xg.GetXrefNode(i);

  193 

  194             switch (xgn.XrefStatus)

  195             {

  196               // If Un*, print a message

  197 

  198               case XrefStatus.Unresolved:

  199                 ed.WriteMessage(

  200                   "\nUnresolved xref \"{0}\"", xgn.Name

  201                 );

  202                 break;

  203               case XrefStatus.Unloaded:

  204                 ed.WriteMessage(

  205                   "\nUnloaded xref \"{0}\"", xgn.Name

  206                 );

  207                 break;

  208               case XrefStatus.Unreferenced:

  209                 ed.WriteMessage(

  210                   "\nUnreferenced xref \"{0}\"", xgn.Name

  211                 );

  212                 break;

  213               case XrefStatus.Resolved:

  214                 {

  215                   // If Resolved, get the RegAppTable

  216 

  217                   Database xdb = xgn.Database;

  218                   if (xdb != null)

  219                   {

  220                     Transaction tr =

  221                     xdb.TransactionManager.StartTransaction();

  222                     using (tr)

  223                     {

  224                       RegAppTable rat =

  225                         (RegAppTable)tr.GetObject(

  226                           xdb.RegAppTableId,

  227                           OpenMode.ForRead

  228                         );

  229 

  230                       // We'll store our RegApp data in an

  231                       // object

  232 

  233                       RegAppData dwgData = new RegAppData();

  234                       dwgData.Name =

  235                         (i == 0 ?

  236                           Path.GetFileNameWithoutExtension(

  237                             xgn.Name

  238                           ) :

  239                           xgn.Name

  240                         );

  241                       dwgData.File = xdb.Filename;

  242                       dwgData.DwgVersion =

  243                         xdb.OriginalFileVersion.ToString();

  244 

  245                       // Collect the contained names of the

  246                       // RegAppTableRecords (the RegAppIds)

  247                       // in a list

  248 

  249                       foreach (ObjectId id in rat)

  250                       {

  251                         RegAppTableRecord ratr =

  252                           (RegAppTableRecord)tr.GetObject(

  253                             id,

  254                             OpenMode.ForRead

  255                           );

  256                         dwgData.AddRegAppId(ratr.Name);

  257                       }

  258 

  259                       // Store the object in our dictionary,

  260                       // replacing any existing item

  261                       // (keyed off the entire DWG path, not

  262                       // just the name)

  263 

  264                       if (regData.ContainsKey(dwgData.File))

  265                         regData.Remove(dwgData.File);

  266                       regData.Add(dwgData.File, dwgData);

  267 

  268                       // Print the drawing information

  269                       // and the RegAppId count

  270 

  271                       ed.WriteMessage(

  272                         "\nDrawing \"{0}\" (\"{1}\") with " +

  273                         "{2} RegAppIds",

  274                         dwgData.Name,

  275                         dwgData.File,

  276                         dwgData.RegAppIds.Count

  277                       );

  278 

  279                       // Even if only reading, commit the

  280                       // transaction (it's cheaper than

  281                       // aborting)

  282 

  283                       tr.Commit();

  284                     }

  285                   }

  286                   break;

  287                 }

  288             }

  289           }

  290           // Save our data to XML

  291 

  292           SerializeRegAppData(regData);

  293         }

  294       }

  295       catch (System.Exception ex)

  296       {

  297         ed.WriteMessage(

  298           "\nProblem reading/processing \"{0}\": {1}",

  299           pr.StringResult, ex.Message

  300         );

  301       }

  302     }

  303   }

  304 }

The changes are very minor: we’ve added a DwgVersion attribute to our XML, as well as adjusting the save type of RegAppIds from being a simple string attribute to an array of elements (which allows us to determine the number of RegAppIds per drawing more easily).

We've hardcoded the path of the XML file to C:\ (feel free to change this, of course), as well as writing a stylesheet reference directly into the XML to just let the browser take care of the transformation to HTML.

Speaking of the stylesheet, here’s the RegAppData.xslt file to be placed alongside the XML output (currently in C:\, as just mentioned):

<?xml version="1.0" encoding="utf-8"?>

<xsl:stylesheet

  version="1.0"

  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

>

  <xsl:output method="html" indent="yes" version="4.0"/>

 

  <xsl:template match="ArrayOfRegAppData">

    <h2>Registered application IDs per drawing</h2>

    <table>

      <tr>

        <td><em>Drawing name</em></td>

        <td>

          <em>Number of RegAppIds</em>

        </td>

      </tr>

      <xsl:apply-templates select="*"/>

    </table>

  </xsl:template>

 

  <xsl:template match="RegAppData">

    <tr>

      <td>

        <b>

          <xsl:attribute name="Title">

            <xsl:value-of select="@File"/>

            <xsl:text> (</xsl:text>

            <xsl:value-of select="@DwgVersion"/>

            <xsl:text>)</xsl:text>

          </xsl:attribute>

          <xsl:value-of select="@Name"/>

        </b>

      </td>

      <td>

        <xsl:attribute name="Title">

          <xsl:for-each select="RegAppIds/RegAppId">

            <xsl:value-of select="node()"/>

            <xsl:if test="position() != last()">

              <xsl:text>&#x0A;</xsl:text>

            </xsl:if>

          </xsl:for-each>

        </xsl:attribute>

        <center>

          <xsl:value-of select="count(RegAppIds/RegAppId)"/>

        </center>

      </td>

    </tr>

  </xsl:template>

</xsl:stylesheet>

The stylesheet is also quite simple: it creates an HTML file containing a table of two columns – one with the names of our drawings (with the path and version in a tooltip) and the number of RegAppIds found in that drawing (with the specific names in a tooltip). We’ll see that in action a bit.

Running the XRA command just as we did in the last post, we should see this kind of XML output:

<?xml-stylesheet type="text/xsl" href="RegAppData.xslt"?>

<ArrayOfRegAppData

  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

  xmlns:xsd="http://www.w3.org/2001/XMLSchema">

  <RegAppData

    Name="A-01"

    File="C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Architectural\A-01.dwg"

    DwgVersion="Current">

    <RegAppIds>

      <RegAppId>ACAD</RegAppId>

      <RegAppId>CONTENTBLOCKDESCRIPTION</RegAppId>

      <RegAppId>CONTENTBLOCKICON</RegAppId>

      <RegAppId>CONTENTTABDATA</RegAppId>

      <RegAppId>CONTENTCURRENTTAB</RegAppId>

      <RegAppId>ACAD_PSEXT</RegAppId>

      <RegAppId>PE_URL</RegAppId>

      <RegAppId>RAK</RegAppId>

      <RegAppId>AcAecLayerStandard</RegAppId>

      <RegAppId>ACAD_DSTYLE_DIMTEXT_FILL</RegAppId>

      <RegAppId>ACAD_EXEMPT_FROM_CAD_STANDARDS</RegAppId>

      <RegAppId>AcDbBlockRepETag</RegAppId>

      <RegAppId>AcDbDynamicBlockTrueName</RegAppId>

      <RegAppId>AcDbDynamicBlockGUID</RegAppId>

      <RegAppId>AcDbBlockRepBTag</RegAppId>

      <RegAppId>ACAD_DSTYLE_DIMEXT_LENGTH</RegAppId>

      <RegAppId>ACAD_DSTYLE_DIMEXT_ENABLED</RegAppId>

      <RegAppId>ACAD_DSTYLE_DIM_LINETYPE</RegAppId>

      <RegAppId>ACAD_DSTYLE_DIM_EXT1_LINETYPE</RegAppId>

      <RegAppId>ACAD_DSTYLE_DIM_EXT2_LINETYPE</RegAppId>

      <RegAppId>ACAD_MLEADERVER</RegAppId>

    </RegAppIds>

  </RegAppData>

  <RegAppData

    Name="Grid Plan"

    File="C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Architectural\Res\Grid Plan.dwg"

    DwgVersion="AC1021">

    <RegAppIds>

      <RegAppId>ACAD</RegAppId>

      <RegAppId>CONTENTBLOCKDESCRIPTION</RegAppId>

      <RegAppId>CONTENTBLOCKICON</RegAppId>

      <RegAppId>CONTENTTABDATA</RegAppId>

      <RegAppId>CONTENTCURRENTTAB</RegAppId>

      <RegAppId>ACAD_PSEXT</RegAppId>

      <RegAppId>ACAD_DSTYLE_DIMTEXT_FILL</RegAppId>

    </RegAppIds>

  </RegAppData>

  <RegAppData

    Name="Wall Base"

    File="C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Architectural\Res\Wall Base.dwg"

    DwgVersion="AC1021">

    <RegAppIds>

      <RegAppId>ACAD</RegAppId>

      <RegAppId>CONTENTBLOCKDESCRIPTION</RegAppId>

      <RegAppId>CONTENTBLOCKICON</RegAppId>

      <RegAppId>CONTENTTABDATA</RegAppId>

      <RegAppId>CONTENTCURRENTTAB</RegAppId>

      <RegAppId>RAK</RegAppId>

      <RegAppId>AcAecLayerStandard</RegAppId>

      <RegAppId>ACAD_PSEXT</RegAppId>

      <RegAppId>PE_URL</RegAppId>

      <RegAppId>ACAD_DSTYLE_DIMTEXT_FILL</RegAppId>

      <RegAppId>ACAD_MLEADERVER</RegAppId>

    </RegAppIds>

  </RegAppData>

  <RegAppData

    Name="Master Site Plan"

    File="C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Civil\Master Site Plan.dwg"

    DwgVersion="AC1021">

    <RegAppIds>

      <RegAppId>ACAD</RegAppId>

      <RegAppId>RAK</RegAppId>

      <RegAppId>DCA_FIGURE_XENT</RegAppId>

      <RegAppId>ADE</RegAppId>

      <RegAppId>ALIGNMENT_DB_APP</RegAppId>

      <RegAppId>SDI_PROFILE</RegAppId>

      <RegAppId>SDSK_POINT</RegAppId>

      <RegAppId>SVPLINE</RegAppId>

      <RegAppId>ADCADD_ZZ</RegAppId>

      <RegAppId>SDSK_PMN</RegAppId>

      <RegAppId>CIVIL_DRAFT</RegAppId>

      <RegAppId>CIVIL_LINE_TABLE</RegAppId>

      <RegAppId>CIVIL_CURVE_TABLE</RegAppId>

      <RegAppId>CIVIL_SPIRAL_TABLE</RegAppId>

      <RegAppId>SDI_XSECTIONS</RegAppId>

      <RegAppId>ACAD_PSEXT</RegAppId>

      <RegAppId>ACAD_MLEADERVER</RegAppId>

      <RegAppId>DCO15</RegAppId>

    </RegAppIds>

  </RegAppData>

  <RegAppData

    Name="PB-BASE"

    File="C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Civil\PB-BASE.dwg"

    DwgVersion="AC1021">

    <RegAppIds>

      <RegAppId>ACAD</RegAppId>

      <RegAppId>RAK</RegAppId>

      <RegAppId>DCA_FIGURE_XENT</RegAppId>

      <RegAppId>ALIGNMENT_DB_APP</RegAppId>

      <RegAppId>SDI_PROFILE</RegAppId>

      <RegAppId>ACAD_PSEXT</RegAppId>

      <RegAppId>ACAD_MLEADERVER</RegAppId>

    </RegAppIds>

  </RegAppData>

  <RegAppData

    Name="PB-EX41"

    File="C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Civil\PB-EX41.dwg"

    DwgVersion="AC1021">

    <RegAppIds>

      <RegAppId>ACAD</RegAppId>

      <RegAppId>SDSK_POINT</RegAppId>

      <RegAppId>SVPLINE</RegAppId>

      <RegAppId>ACAD_PSEXT</RegAppId>

      <RegAppId>DCO15</RegAppId>

      <RegAppId>ACAD_MLEADERVER</RegAppId>

    </RegAppIds>

  </RegAppData>

  <RegAppData

    Name="PB-EX61"

    File="C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Civil\PB-EX61.dwg"

    DwgVersion="AC1021">

    <RegAppIds>

      <RegAppId>ACAD</RegAppId>

      <RegAppId>SVPLINE</RegAppId>

      <RegAppId>ACAD_PSEXT</RegAppId>

      <RegAppId>DCO15</RegAppId>

      <RegAppId>ACAD_MLEADERVER</RegAppId>

    </RegAppIds>

  </RegAppData>

</ArrayOfRegAppData>

Which, when loaded into a browser, should be displayed like this:

As we hover over the name of a drawing in which we’re interested, we see its path and drawing version:

And as we hover over the RegAppId count, we see the names of the individual IDs:

That’s it for this post. We’ll wrap this series up by making some modifications to ScriptPro 2.0 in the next post.

Persisting RegAppId data from an external AutoCAD drawing to XML using .NET

This post takes the code from the last post and extends it to serialize the collected RegAppId data to an XML file, as per Step 3 below:

1. Implement a command to collect RegAppId information for the active document
2. Extend this command to work on a drawing not loaded in the editor
3. Save our RegAppId information to some persistent location (XML)
4. Create a modified version of ScriptPro 2.0 (one of our Plugins of the Month) to call our command without opening the drawing

I’ve chosen once again to leverage the very handy XmlSerializer class to handle serialization to and from XML: all we have to do is get our data in a data structure with appropriate metadata and the rest is taken care of by .NET. More or less, anyway. :-)

Here’s the updated code, with the new/modified lines in red (and here’s the updated source file):

    1 using Autodesk.AutoCAD.ApplicationServices;

    2 using Autodesk.AutoCAD.DatabaseServices;

    3 using Autodesk.AutoCAD.EditorInput;

    4 using Autodesk.AutoCAD.Runtime;

    5 using System.Collections.Generic;

    6 using System.Text;

    7 using System.Xml;

    8 using System.Xml.Serialization;

    9 using System.IO;

   10 using System;

   11 

   12 namespace XrefRegApps

   13 {

   14   [XmlRoot("RegAppData")]

   15   public class RegAppData

   16   {

   17     // The name of our drawing

   18 

   19     private string _name;

   20 

   21     [XmlAttribute("Name")]

   22     public string Name

   23     {

   24       get { return _name; }

   25       set { _name = value; }

   26     }

   27 

   28     // The location of our drawing

   29 

   30     private string _dwg;

   31 

   32     [XmlAttribute("File")]

   33     public string File

   34     {

   35       get { return _dwg; }

   36       set { _dwg = value; }

   37     }

   38 

   39     // The list of our drawing's Registered Application IDs

   40 

   41     private List<string> _regAppIds = new List<string>();

   42 

   43     [XmlAttribute("RegAppIds")]

   44     public List<string> RegAppIds

   45     {

   46       get { return _regAppIds; }

   47       set { _regAppIds = value; }

   48     }

   49 

   50     public void AddRegAppId(string id)

   51     {

   52       if (!_regAppIds.Contains(id))

   53         _regAppIds.Add(id);

   54     }

   55   }

   56 

   57   public class Commands

   58   {

   59     private const string regAppDataXml = "RegAppData.xml";

   60 

   61     private void SerializeRegAppData(

   62       Dictionary<string, RegAppData> dict

   63     )

   64     {

   65       if (dict.Count > 0)

   66       {

   67         // No direct way to serialize a dictionary to XML,

   68         // so we'll create a list from it and serialize that

   69 

   70         List<RegAppData> regData =

   71           new List<RegAppData>(dict.Count);

   72         foreach (KeyValuePair<string, RegAppData> kv in dict)

   73         {

   74           regData.Add(kv.Value);

   75         }

   76 

   77         // Serialize our list to the specified XML file

   78 

   79         XmlSerializer xs =

   80           new XmlSerializer(typeof(List<RegAppData>));

   81         XmlTextWriter xw =

   82           new XmlTextWriter(regAppDataXml, Encoding.UTF8);

   83         xs.Serialize(xw, regData);

   84         xw.Close();

   85       }

   86     }

   87 

   88     // Read and return the previous Registered Application data

   89     // from our stored XML file

   90 

   91     private Dictionary<string, RegAppData>

   92       DeserializeRegAppData()

   93     {

   94       if (File.Exists(regAppDataXml))

   95       {

   96         XmlSerializer xs =

   97           new XmlSerializer(typeof(List<RegAppData>));

   98         XmlTextReader xr = new XmlTextReader(regAppDataXml);

   99         if (xs.CanDeserialize(xr))

  100         {

  101           // No direct way to serialize a dictionary to XML,

  102           // so we'll read a list and populate a dictionary

  103           // from it

  104 

  105           List<RegAppData> regData =

  106             (List<RegAppData>)xs.Deserialize(xr);

  107           xr.Close();

  108           Dictionary<string, RegAppData> dict =

  109             new Dictionary<string, RegAppData>();

  110           foreach (RegAppData rad in regData)

  111           {

  112             dict.Add(rad.File, rad);

  113           }

  114           return dict;

  115         }

  116       }

  117       return new Dictionary<string, RegAppData>();

  118     }

  119 

  120     [CommandMethod("XRA")]

  121     public void ExternalReferenceRegisteredApps()

  122     {

  123       Document doc =

  124           Application.DocumentManager.MdiActiveDocument;

  125       Database db = doc.Database;

  126       Editor ed = doc.Editor;

  127 

  128       // Prompt the user for the path to a DWG to test

  129 

  130       PromptStringOptions pso =

  131         new PromptStringOptions(

  132           "\nEnter path to root drawing file: "

  133         );

  134       pso.AllowSpaces = true;

  135       PromptResult pr = ed.GetString(pso);

  136       if (pr.Status != PromptStatus.OK)

  137         return;

  138 

  139       if (!File.Exists(pr.StringResult))

  140       {

  141         ed.WriteMessage("\nFile does not exist.");

  142         return;

  143       }

  144 

  145       try

  146       {

  147         // We start by reading any existing RegApp data

  148         // from XML

  149 

  150         Dictionary<string, RegAppData> regData =

  151           DeserializeRegAppData();

  152 

  153         // Load the DWG into a side database

  154 

  155         Database mainDb = new Database(false, true);

  156         using (mainDb)

  157         {

  158           mainDb.ReadDwgFile(

  159             pr.StringResult,

  160             FileOpenMode.OpenForReadAndAllShare,

  161             true,

  162             null

  163           );

  164 

  165           // We need an additional step to resolve Xrefs

  166 

  167           mainDb.ResolveXrefs(false, false);

  168 

  169           // Get the XrefGraph for the specified database

  170 

  171           XrefGraph xg = mainDb.GetHostDwgXrefGraph(true);

  172 

  173           // Loop through the nodes in the graph

  174 

  175           for (int i = 0; i < xg.NumNodes; i++)

  176           {

  177             // Get each node and check its status

  178 

  179             XrefGraphNode xgn = xg.GetXrefNode(i);

  180 

  181             switch (xgn.XrefStatus)

  182             {

  183               // If Un*, print a message

  184 

  185               case XrefStatus.Unresolved:

  186                 ed.WriteMessage(

  187                   "\nUnresolved xref \"{0}\"", xgn.Name

  188                 );

  189                 break;

  190               case XrefStatus.Unloaded:

  191                 ed.WriteMessage(

  192                   "\nUnloaded xref \"{0}\"", xgn.Name

  193                 );

  194                 break;

  195               case XrefStatus.Unreferenced:

  196                 ed.WriteMessage(

  197                   "\nUnreferenced xref \"{0}\"", xgn.Name

  198                 );

  199                 break;

  200               case XrefStatus.Resolved:

  201                 {

  202                   // If Resolved, get the RegAppTable

  203 

  204                   Database xdb = xgn.Database;

  205                   if (xdb != null)

  206                   {

  207                     Transaction tr =

  208                     xdb.TransactionManager.StartTransaction();

  209                     using (tr)

  210                     {

  211                       RegAppTable rat =

  212                         (RegAppTable)tr.GetObject(

  213                           xdb.RegAppTableId,

  214                           OpenMode.ForRead

  215                         );

  216 

  217                       // We'll store our RegApp data in an

  218                       // object

  219 

  220                       RegAppData dwgData = new RegAppData();

  221                       dwgData.Name =

  222                         (i == 0 ?

  223                           Path.GetFileNameWithoutExtension(

  224                             xgn.Name

  225                           ) :

  226                           xgn.Name

  227                         );

  228                       dwgData.File = xdb.Filename;

  229 

  230                       // Collect the contained names of the

  231                       // RegAppTableRecords (the RegAppIds)

  232                       // in a list

  233 

  234                       foreach (ObjectId id in rat)

  235                       {

  236                         RegAppTableRecord ratr =

  237                           (RegAppTableRecord)tr.GetObject(

  238                             id,

  239                             OpenMode.ForRead

  240                           );

  241                         dwgData.AddRegAppId(ratr.Name);

  242                       }

  243 

  244                       // Store the object in our dictionary,

  245                       // replacing any existing item

  246                       // (keyed off the entire DWG path, not

  247                       // just the name)

  248 

  249                       if (regData.ContainsKey(dwgData.File))

  250                         regData.Remove(dwgData.File);

  251                       regData.Add(dwgData.File, dwgData);

  252 

  253                       // Print the drawing information

  254                       // and the RegAppId count

  255 

  256                       ed.WriteMessage(

  257                         "\nDrawing \"{0}\" (\"{1}\") with " +

  258                         "{2} RegAppIds",

  259                         dwgData.Name,

  260                         dwgData.File,

  261                         dwgData.RegAppIds.Count

  262                       );

  263 

  264                       // Even if only reading, commit the

  265                       // transaction (it's cheaper than

  266                       // aborting)

  267 

  268                       tr.Commit();

  269                     }

  270                   }

  271                   break;

  272                 }

  273             }

  274           }

  275           // Save our data to XML

  276 

  277           SerializeRegAppData(regData);

  278         }

  279       }

  280       catch (System.Exception ex)

  281       {

  282         ed.WriteMessage(

  283           "\nProblem reading/processing \"{0}\": {1}",

  284           pr.StringResult, ex.Message

  285         );

  286       }

  287     }

  288   }

  289 }

When we first run the XRA command with our Civil sample file, we see the contents of the XML file (which seems to be written to the current directory – we could easily hardcode another location, of course) are:

  <?xml version="1.0" encoding="utf-8" ?>

- <ArrayOfRegAppData xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">

  <RegAppData Name="Master Site Plan" File="C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Civil\Master Site Plan.dwg" RegAppIds="ACAD RAK DCA_FIGURE_XENT ADE ALIGNMENT_DB_APP SDI_PROFILE SDSK_POINT SVPLINE ADCADD_ZZ SDSK_PMN CIVIL_DRAFT CIVIL_LINE_TABLE CIVIL_CURVE_TABLE CIVIL_SPIRAL_TABLE SDI_XSECTIONS ACAD_PSEXT ACAD_MLEADERVER DCO15" />

  <RegAppData Name="PB-BASE" File="C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Civil\PB-BASE.dwg" RegAppIds="ACAD RAK DCA_FIGURE_XENT ALIGNMENT_DB_APP SDI_PROFILE ACAD_PSEXT ACAD_MLEADERVER" />

  <RegAppData Name="PB-EX41" File="C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Civil\PB-EX41.dwg" RegAppIds="ACAD SDSK_POINT SVPLINE ACAD_PSEXT DCO15 ACAD_MLEADERVER" />

  <RegAppData Name="PB-EX61" File="C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Civil\PB-EX61.dwg" RegAppIds="ACAD SVPLINE ACAD_PSEXT DCO15 ACAD_MLEADERVER" />

  </ArrayOfRegAppData>

if we run the XRA command again, this time specifying a file from the Architectural sample:

Command: XRA

Enter path to root drawing file: C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Architectural\A-01.dwg

Drawing "A-01" ("C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Architectural\A-01.dwg") with 21 RegAppIds

Drawing "Grid Plan" ("C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Architectural\Res\Grid Plan.dwg") with 7 RegAppIds

Drawing "Wall Base" ("C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Architectural\Res\Wall Base.dwg") with 11 RegAppIds

We will see the XML now contains additional entries:

  <?xml version="1.0" encoding="utf-8" ?>

- <ArrayOfRegAppData xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">

  <RegAppData Name="Master Site Plan" File="C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Civil\Master Site Plan.dwg" RegAppIds="ACAD RAK DCA_FIGURE_XENT ADE ALIGNMENT_DB_APP SDI_PROFILE SDSK_POINT SVPLINE ADCADD_ZZ SDSK_PMN CIVIL_DRAFT CIVIL_LINE_TABLE CIVIL_CURVE_TABLE CIVIL_SPIRAL_TABLE SDI_XSECTIONS ACAD_PSEXT ACAD_MLEADERVER DCO15" />

  <RegAppData Name="PB-BASE" File="C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Civil\PB-BASE.dwg" RegAppIds="ACAD RAK DCA_FIGURE_XENT ALIGNMENT_DB_APP SDI_PROFILE ACAD_PSEXT ACAD_MLEADERVER" />

  <RegAppData Name="PB-EX41" File="C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Civil\PB-EX41.dwg" RegAppIds="ACAD SDSK_POINT SVPLINE ACAD_PSEXT DCO15 ACAD_MLEADERVER" />

  <RegAppData Name="PB-EX61" File="C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Civil\PB-EX61.dwg" RegAppIds="ACAD SVPLINE ACAD_PSEXT DCO15 ACAD_MLEADERVER" />

  <RegAppData Name="A-01" File="C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Architectural\A-01.dwg" RegAppIds="ACAD CONTENTBLOCKDESCRIPTION CONTENTBLOCKICON CONTENTTABDATA CONTENTCURRENTTAB ACAD_PSEXT PE_URL RAK AcAecLayerStandard ACAD_DSTYLE_DIMTEXT_FILL ACAD_EXEMPT_FROM_CAD_STANDARDS AcDbBlockRepETag AcDbDynamicBlockTrueName AcDbDynamicBlockGUID AcDbBlockRepBTag ACAD_DSTYLE_DIMEXT_LENGTH ACAD_DSTYLE_DIMEXT_ENABLED ACAD_DSTYLE_DIM_LINETYPE ACAD_DSTYLE_DIM_EXT1_LINETYPE ACAD_DSTYLE_DIM_EXT2_LINETYPE ACAD_MLEADERVER" />

  <RegAppData Name="Grid Plan" File="C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Architectural\Res\Grid Plan.dwg" RegAppIds="ACAD CONTENTBLOCKDESCRIPTION CONTENTBLOCKICON CONTENTTABDATA CONTENTCURRENTTAB ACAD_PSEXT ACAD_DSTYLE_DIMTEXT_FILL" />

  <RegAppData Name="Wall Base" File="C:\Program Files\Autodesk\AutoCAD 2011\Sample\Sheet Sets\Architectural\Res\Wall Base.dwg" RegAppIds="ACAD CONTENTBLOCKDESCRIPTION CONTENTBLOCKICON CONTENTTABDATA CONTENTCURRENTTAB RAK AcAecLayerStandard ACAD_PSEXT PE_URL ACAD_DSTYLE_DIMTEXT_FILL ACAD_MLEADERVER" />

  </ArrayOfRegAppData>

This is really a reasonably simple way of storing our data: it should be trivial to add additional data to the XML, such as the version of the DWG, an entry holding the number of entries in the RegAppId list (although we do have the list itself).

In the next post we may move on to modifying ScriptPro 2.0, but we may take a quick detour and put together an XML stylesheet to visualize the data – let’s see next week.

Combining AutoCAD blocks in separate files into a single DWG using .NET – Take 2

Thanks for Chris, Dan and Dale for pointing out the obvious issue(s) with my last post. Let’s just blame it on a few holiday cobwebs needing brushing away during the first week back in the saddle. :-)

The main issue with my previous implementation was that I’d somehow forgotten that Database.Insert() allows you to insert into a named block definition. This simple function does all my previous, manual approach did and more.

The secondary issue – but still very important to those using annotation scaling – is that the previous code does not work for annotative blocks, as Dan very rightly pointed out. I’ve incorporated Dan’s approach into today’s post to make it more complete.

I’ve decided to leave the original post as it is – as the technique is somewhat interesting at a certain level – even if today’s post supercedes it.

Here’s the updated C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using System.IO;

using System;

 

namespace BlockImport

{

  public class BlockImportClass

  {

    [CommandMethod("CBL")]

    public void CombineBlocksIntoLibrary()

    {

      Document doc =

          Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

      Database destDb = doc.Database;

 

      // Get name of folder from which to load and import blocks

 

      PromptResult pr =

        ed.GetString("\nEnter the folder of source drawings: ");

 

      if (pr.Status != PromptStatus.OK)

        return;

      string pathName = pr.StringResult;

 

      // Check the folder exists

 

      if (!Directory.Exists(pathName))

      {

        ed.WriteMessage(

          "\nDirectory does not exist: {0}", pathName

        );

        return;

      }

 

      // Get the names of our DWG files in that folder

 

      string[] fileNames = Directory.GetFiles(pathName, "*.dwg");

 

      // A counter for the files we've imported

 

      int imported = 0, failed = 0;

 

      // For each file in our list

 

      foreach (string fileName in fileNames)

      {

        // Double-check we have a DWG file (probably unnecessary)

 

        if (fileName.EndsWith(

              ".dwg",

              StringComparison.InvariantCultureIgnoreCase

            )

        )

        {

          // Catch exceptions at the file level to allow skipping

 

          try

          {

            // Suggestion from Thorsten Meinecke...

 

            string destName =

              SymbolUtilityServices.GetSymbolNameFromPathName(

                fileName, "dwg"

              );

 

            // And from Dan Glassman...

 

            destName =

              SymbolUtilityServices.RepairSymbolName(

                destName, false

              );

 

            // Create a source database to load the DWG into

 

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

            {

              // Read the DWG into our side database

 

              db.ReadDwgFile(fileName, FileShare.Read, true, "");

              bool isAnno = db.AnnotativeDwg;

 

              // Insert it into the destination database as

              // a named block definition

 

              ObjectId btrId = destDb.Insert(

                destName,

                db,

                false

              );

 

              if (isAnno)

              {

                // If an annotative block, open the resultant BTR

                // and set its annotative definition status

 

                Transaction tr =

                  destDb.TransactionManager.StartTransaction();

                using (tr)

                {

                  BlockTableRecord btr =

                    (BlockTableRecord)tr.GetObject(

                      btrId,

                      OpenMode.ForWrite

                    );

                  btr.Annotative = AnnotativeStates.True;

                  tr.Commit();

                }

              }

 

              // Print message and increment imported block counter

 

              ed.WriteMessage("\nImported from \"{0}\".", fileName);

              imported++;

            }

          }

          catch (System.Exception ex)

          {

            ed.WriteMessage(

              "\nProblem importing \"{0}\": {1} - file skipped.",

              fileName, ex.Message

            );

            failed++;

          }

        }

      }

 

      ed.WriteMessage(

        "\nImported block definitions from {0} files{1} in " +

        "\"{2}\" into the current drawing.",

        imported,

        failed > 0 ? " (" + failed + " failed)" : "",

        pathName

      );

    }

  }

}

The results are just as we saw with the previous code, so I won’t repeat them.

Update

I made a small update to the code, to make use of SymbolUtilityServices.GetSymbolNameFromPathName() rather than Path.GetFileNameWithoutExtension(). Thanks to Thorsten Meinecke for making this suggestion.

Update 2

Followed by a minor code update to fix simplify the post-edit of annotative block definitions as well as an additional call to SymbolUtilityServices.RepairSymbolName() recommended by Dan Glassman (thanks, Dan! :-).