Through the Interface: Drawing structure

Sun	Mon	Tue	Wed	Thu	Fri	Sat
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30

Drawing structure

November 19, 2009

Preview of December’s Plugin of the Month: Layer Reporter

I feel like I’m posting a lot about our Plugin of the Month initiative, at the moment, but then I suppose it’s to some degree a function of what I’m spending time on. It’s definitely eating into the time I would normally focus on blogging… after a number of AU-related posts coming out over the next few weeks (as I finish my AU prep next week and then blog from the event the week after) I’d hope to return to somewhat more typical posts in December (although as I’m going on to Japan, Korea and China from Las Vegas, this might be a bit optimistic).

Anyway, I thought it was a good time to unveil December’s plugin, a tool donated by our old friend Terry Dotson. Terry’s company, DotSoft, has been a member of the Autodesk Developer Network since 1992 (since before it was even called ADN, in fact :-). I’ve spent a little time changing variable names and reformatting the code to be consistent with this blog, but the techniques shown are very much Terry’s.

I really like this tool: it makes heavy use of the WinForms web browser control (System.Windows.Forms.WebBrowser) to display a report generated from the contents of the active drawing’s layer table. The application generates HTML based on the layers in the drawing and then saves it to a temporary folder before loading it into the browser control. The original implementation just set the DocumentText of the browser, but we found this limited the formats the control could save to (more on this feature in a moment). Once the report is displayed the user can customize the font and font-size as well as the choice of which columns to include in the report. These settings get saved by the application, so if you wish to generate reports for multiple drawings there’s not need to make the changes each time. Once the report looks right you can save it to file – whether to a web archive (.MHT), complete or simple web pages (.HTM) or to a plain text file (.TXT) – or print it.

Here’s an example of the results of the REPORTLAYERS command on a blank drawing:

Now let’s run it on a more complex drawing with more layers, and adjust the settings to suit our particular needs:

We can save the report…

We can configure its page setup…

Preview the print session…

Or just go ahead and print it directly…

Now for the code. The application was written in VB.NET (which is great, as it gives us – so far – a monthly alternation between C# and VB). You can download a preview version of the tool with source code here.

Here’s the main “code behind” the Report class, which does the bulk of the work:

Imports Autodesk.AutoCAD.DatabaseServices
Imports Autodesk.AutoCAD.ApplicationServices
Imports Autodesk.AutoCAD.Colors
Imports System.Text
Imports System.Drawing
 
Public Class Report
 
  Private _init As Boolean
  Private _bmps As New Dictionary(Of String, String)
  Private _tmpHtm As String = ""
 
  Private Const kApp = "ADNPlugin-LayerReporter"
  Private Const kSec = "GenerateReport"
  Private Const kFontName = "FontName"
  Private Const kFontSize = "FontSize"
  Private Const kRetainBmps = "RetainBitmaps"
  Private Const kFieldFlags = "FieldFlags"
 
  Private Sub AppReport_FormClosing( _
    ByVal sender As Object, _
    ByVal e As System.Windows.Forms.FormClosingEventArgs) _
    Handles Me.FormClosing
 
    Dim flags As Int32 = 0
    If statusFld.Checked Then flags += 1
    If onFld.Checked Then flags += 2
    If freezeFld.Checked Then flags += 4
    If lockFld.Checked Then flags += 8
    If colorFld.Checked Then flags += 16
    If ltypeFld.Checked Then flags += 32
    If lweightFld.Checked Then flags += 64
    If pstyleFld.Checked Then flags += 128
    If plotFld.Checked Then flags += 256
    If descFld.Checked Then flags += 512
    If xrefsFld.Checked Then flags += 1024
 
    SaveSetting(kApp, kSec, kFontName, fontName.Text)
    SaveSetting(kApp, kSec, kFontSize, fontSize.Text)
    SaveSetting(kApp, kSec, kRetainBmps, bmpsFld.Checked)
    SaveSetting(kApp, kSec, kFieldFlags, flags)
 
    ' Clean up temporary bitmaps?
 
    If Not bmpsFld.Checked Then
      For Each kv As KeyValuePair(Of String, String) In _bmps
        If File.Exists(kv.Value) Then
          File.Delete(kv.Value)
        End If
      Next
    End If
 
    If _tmpHtm <> "" And File.Exists(_tmpHtm) Then
      File.Delete(_tmpHtm)
    End If
 
  End Sub
 
  Private Sub AppReport_Load( _
    ByVal sender As System.Object, _
    ByVal e As System.EventArgs) _
    Handles MyBase.Load
 
    _init = True
 
    ' Export bitmaps to Temp folder and store in dictionary.
    ' This lets us easily refer to the bitmap file by key name
    ' later and get the files when it's time to clean up.
 
    Dim tmpLoc As String = Path.GetTempPath
    Dim bmps() As String = _
      {"frz", "loc", "nop", "off", "onn", "plt", _
      "thw", "unl", "use", "unu"}
 
    For Each key As String In bmps
      Dim resname As String = "lay" & key
      Dim fname As String = tmpLoc & resname & ".bmp"
      _bmps.Add(key, fname)
      Using tmpBmp As Bitmap = _
        My.Resources.ResourceManager.GetObject(resname)
        tmpBmp.Save(fname)
      End Using
    Next
    ' Put font names in popdown list
    For Each fntFam As FontFamily In FontFamily.Families
      fontName.Items.Add(fntFam.Name)
    Next
 
    fontName.Text = _
      GetSetting(kApp, kSec, kFontName, "Arial")
    fontSize.Text = _
      GetSetting(kApp, kSec, kFontSize, "medium")
    bmpsFld.Checked = _
      GetSetting(kApp, kSec, kRetainBmps, False)
    Dim flags As Int32 = _
      GetSetting(kApp, kSec, kFieldFlags, 1023)
 
    statusFld.Checked = flags And 1
    onFld.Checked = flags And 2
    freezeFld.Checked = flags And 4
    lockFld.Checked = flags And 8
    colorFld.Checked = flags And 16
    ltypeFld.Checked = flags And 32
    lweightFld.Checked = flags And 64
    pstyleFld.Checked = flags And 128
    plotFld.Checked = flags And 256
    descFld.Checked = flags And 512
    xrefsFld.Checked = flags And 1024
 
    Call GenerateReport()
    _init = False
 
  End Sub
 
  ' The SelectedIndexChanged event fires when the user changes
  ' a value in the related popdown menu at the top of the form.
  Private Sub fontName_SelectedIndexChanged( _
    ByVal sender As Object, _
    ByVal e As System.EventArgs) _
    Handles fontName.SelectedIndexChanged
 
    If Not _init Then
      Call GenerateReport()
    End If
  End Sub
 
  Private Sub fontSize_SelectedIndexChanged( _
    ByVal sender As Object, _
    ByVal e As System.EventArgs) _
    Handles fontSize.SelectedIndexChanged
 
    If Not _init Then
      Call GenerateReport()
    End If
  End Sub
 
  ' Shared Sub handles all Options toggles to regenerate
  ' the report, note that each click event is included and
  ' separated by commas.
 
  Private Sub MenuReact( _
    ByVal sender As System.Object, _
    ByVal e As System.EventArgs) _
    Handles statusFld.Click, onFld.Click, freezeFld.Click, _
            lockFld.Click, colorFld.Click, ltypeFld.Click, _
            lweightFld.Click, pstyleFld.Click, plotFld.Click, _
            descFld.Click, xrefsFld.Click
 
    Call GenerateReport()
  End Sub
 
  Private Sub GenerateReport()
 
    ' Dimension some variables as placeholders for repeatedly
    ' used strings for smaller more readable code below.
 
    Dim dwg As String = _
      Application.GetSystemVariable("DWGPREFIX") & _
      Application.GetSystemVariable("DWGNAME")
    Dim stylePre As String = _
      "style='font-family: " & fontName.Text & "; font-size: " & _
      fontSize.Text
    Dim headPre As String = "<th>" & "&nbsp;"
    Dim headSuf As String = "&nbsp;" & "</th>"
    Dim imgPre As String = _
      "<td align='center'>&nbsp;<img src='"
    Dim imgSuf As String = "'/>&nbsp;</td>"
    Dim txtPre As String = "<td>" & "&nbsp;"
    Dim txtSuf As String = "&nbsp;" & "</td>"
 
    ' Get an instance of the database and layer table and create
    ' a transaction by using 'Using' instead of 'Dim' the instance
    ' will be automatically disposed after execution is complete.
 
    Using db As Database = _
      Application.DocumentManager.MdiActiveDocument.Database
      Using tr As Transaction = _
        db.TransactionManager.StartTransaction
        Using lt As LayerTable = _
          db.LayerTableId.GetObject(OpenMode.ForRead)
 
          ' Loop through the layer table and build a list of
          ' qualifying layer names so we can sort it for output.
          ' The default order is likely the order created.
 
          Dim lays As New List(Of String)
          For Each layId As ObjectId In lt
            Dim ltr As LayerTableRecord = _
              tr.GetObject(layId, OpenMode.ForRead)
            If xrefsFld.Checked Then
              lays.Add(ltr.Name)
            Else
              If Not ltr.IsDependent Then
                lays.Add(ltr.Name)
              End If
            End If
          Next
          lays.Sort()
 
          ' The System.Text.StringBuilder is an extremely fast way
          ' of concatenating strings, see the .NET help for more
          ' details on this versatile object!
 
          Dim sb As New StringBuilder()
          sb.Append( _
            "<html><head>" & _
            "<title>" & dwg & "</title>" & _
            "</head>" & _
            "<body>")
          sb.Append("<center><div " & stylePre & "'>")
          sb.Append( _
            "<b>" & "Layer Report" & _
            "</b>" & "<br/>")
          sb.Append( _
            "<b>" & dwg & "</b>" & "<br/>")
          sb.Append( _
            Format(Now, "Long Date") & "  " & _
            Format(Now, "Long Time") & "<br/>")
          sb.Append( _
            "<table " & stylePre & ";border-collapse: collapse; " & _
            "border='0' " & _
            "cellpadding='0'>")
          sb.Append("<tr>")
          If statusFld.Checked Then
            sb.Append(headPre & "Status" & headSuf)
          End If
          sb.Append(headPre & "Name" & headSuf)
          If onFld.Checked Then
            sb.Append(headPre & "On" & headSuf)
          End If
          If freezeFld.Checked Then
            sb.Append(headPre & "Freeze" & headSuf)
          End If
          If lockFld.Checked Then
            sb.Append(headPre & "Lock" & headSuf)
          End If
          If colorFld.Checked Then
            sb.Append(headPre & "Color" & headSuf)
          End If
          If ltypeFld.Checked Then
            sb.Append(headPre & "Linetype" & headSuf)
          End If
          If lweightFld.Checked Then
            sb.Append(headPre & "Lineweight" & headSuf)
          End If
          If pstyleFld.Checked Then
            sb.Append(headPre & "PlotStyle" & headSuf)
          End If
          If plotFld.Checked Then
            sb.Append(headPre & "Plot" & headSuf)
          End If
          If descFld.Checked Then
            sb.Append(headPre & "Description" & headSuf)
          End If
          sb.Append("</tr>")
          sb.Append("<tr><td>&nbsp;</td></tr>")
 
          ' The title and header section is done, time to fill in
          ' the layer rows.
 
          For Each lay As String In lays
 
            ' Get the layer record by its key name string using the
            ' transactions.GetObject()
 
            Dim ltr As LayerTableRecord = _
              tr.GetObject(lt(lay), OpenMode.ForRead)
            sb.Append("<tr>")
            If statusFld.Checked Then
              sb.Append( _
                imgPre & _
                IIf(ltr.IsUsed, _bmps("use"), _bmps("unu")) & _
                imgSuf)
            End If
            sb.Append(txtPre & ltr.Name & txtSuf)
            If onFld.Checked Then
              sb.Append( _
                imgPre & _
                IIf(ltr.IsOff, _bmps("off"), _bmps("onn")) & _
                imgSuf)
            End If
            If freezeFld.Checked Then
              sb.Append( _
                imgPre & _
                IIf(ltr.IsFrozen, _bmps("frz"), _bmps("thw")) & _
                imgSuf)
            End If
            If lockFld.Checked Then
              sb.Append( _
                imgPre & _
                IIf(ltr.IsLocked, _bmps("loc"), _bmps("unl")) & _
                imgSuf)
            End If
            If colorFld.Checked Then
 
              ' Used so we can show the square bullet in the
              ' layers color
 
              sb.Append( _
                "<td>&nbsp;<span style='font-family: Wingdings; " & _
                "color: " & Col2Str(ltr.Color) & "'>n</span>")
              sb.Append( _
                "&nbsp;" & _
                ltr.Color.ColorNameForDisplay & _
                "&nbsp;" & "</td>")
            End If
            If ltypeFld.Checked Then
 
              ' The layer record stores the linetype as an ObjectId,
              ' not a string.  This means we need to look up the
              ' linetype in that table to get it's string name.
 
              Dim ltt As LinetypeTable = _
                db.LinetypeTableId.GetObject(OpenMode.ForRead)
              Dim lttr As LinetypeTableRecord = _
                tr.GetObject(ltr.LinetypeObjectId, OpenMode.ForRead)
              sb.Append(txtPre & lttr.Name & txtSuf)
            End If
            If lweightFld.Checked Then
              sb.Append( _
                txtPre & _
                Wght2Str(ltr.LineWeight) & _
                txtSuf)
            End If
            If pstyleFld.Checked Then
 
              ' The plot style is stored as a string, we can simply
              ' include it
              sb.Append(txtPre & ltr.PlotStyleName & txtSuf)
            End If
            If plotFld.Checked Then
              sb.Append( _
                imgPre & _
                IIf(ltr.IsPlottable, _bmps("plt"), _bmps("nop")) _
                & imgSuf)
            End If
            If descFld.Checked Then
              sb.Append(txtPre & ltr.Description & txtSuf)
            End If
            sb.Append("</tr>")
          Next
          sb.Append("</table></div></center></body></html>")
 
          ' Write the HTML content to a file and then load it
 
          If _tmpHtm = "" Then
            _tmpHtm = Path.GetTempFileName() + ".htm"
          End If
 
          Using file As StreamWriter = _
            New StreamWriter(_tmpHtm, False, Encoding.Default)
            file.Write(sb.ToString)
            file.Close()
          End Using
          webWin.SuspendLayout()
          webWin.Navigate(_tmpHtm)
 
          ' Wait for the control to finish
 
          While webWin.IsBusy
            System.Windows.Forms.Application.DoEvents()
          End While
          webWin.ResumeLayout()
          statTxt.Text = _
            lays.Count.ToString & " layer" & _
            IIf(lays.Count = 1, "", "s") & " listed"
        End Using
      End Using
    End Using
  End Sub
 
  Private Sub printBut_Click( _
    ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles printBut.Click
 
    webWin.ShowPrintDialog()
  End Sub
 
  Private Sub prevBut_Click( _
    ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles prevBut.Click
 
    webWin.ShowPrintPreviewDialog()
  End Sub
 
  Private Sub saveBut_Click( _
    ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles saveBut.Click
 
    webWin.ShowSaveAsDialog()
  End Sub
 
  Private Sub setupBut_Click( _
    ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles setupBut.Click
 
    webWin.ShowPageSetupDialog()
  End Sub
 
  ' Helper function for the square bullet displayed, takes an _
  ' AutoCAD color as input as returns a string like #00FF00.
 
  Private Function Col2Str( _
    ByVal c As Autodesk.AutoCAD.Colors.Color) As String
 
    Dim col As Int32
    If c.ColorMethod = ColorMethod.ByAci Then
      Dim bytes() As Byte = _
        BitConverter.GetBytes( _
          EntityColor.LookUpRgb(c.ColorIndex))
      col = RGB(bytes(0), bytes(1), bytes(2))
    Else
      col = RGB(c.Blue, c.Green, c.Red)
    End If
    Return ColorTranslator.ToHtml( _
      System.Drawing.Color.FromArgb(col))
  End Function
 
  ' Helper function for lineweights, takes the stored value
  ' and returns  a string similar to AutoCAD's layer dialog
  ' (in the current units).
 
  Private Function Wght2Str(ByVal weight As Single) _
    As String
 
    Select Case weight
      Case -3
        Return "Default"
      Case -2
        Return "ByBlock"
      Case -1
        Return "ByLayer"
      Case Else
        If Application.GetSystemVariable("LWUNITS") = 1 Then
          Return Format(weight / 100.0, "0.00") & "mm"
        Else
          Return Format(weight / 25.4 / 100.0, "0.000") & Chr(34)
        End If
    End Select
  End Function
 
End Class

There’s an additional Commands.vb file:

Imports Autodesk.AutoCAD.ApplicationServices
Imports Autodesk.AutoCAD.Runtime
Imports LayerReporter.DemandLoading
 
Public Class Commands
 
  Implements IExtensionApplication
 
  ' AutoCAD fires the Initialize Sub when the assembly is loaded,
  ' so we check to see if the command is registered by looking for
  ' the existance of the Registry keys.  If not found, we attempt
  ' to add them so the command will automatically load in future
  ' sessions.  This means it only needs to be NETLOADed once.
 
  Public Sub Initialize() Implements IExtensionApplication.Initialize
    RegistryUpdate.RegisterForDemandLoading()
  End Sub
 
  Public Sub Terminate() Implements IExtensionApplication.Terminate
    ' Only fires when AutoCAD is shutting down
  End Sub
 
  <CommandMethod("ADNPLUGINS", "REMOVELR", CommandFlags.Modal)> _
  Public Shared Sub RemoveLayerReporter()
    RegistryUpdate.UnregisterForDemandLoading()
  End Sub
 
  ' Establish our command name to use to start the tool.  It
  ' dimensions an instance of the form and displays it with
  ' AutoCAD's ShowModalDialog.  Don't use Windows Form.Show!
 
  <CommandMethod("ADNPLUGINS", "REPORTLAYERS", CommandFlags.Modal)> _
  Public Shared Sub ReportLayers()
    Using dlg As New Report()
  Application.ShowModalDialog(dlg)
    End Using
  End Sub
 
End Class

And the Demand_Loading.vb file is the same as was used in the ClipboardManager tool.

If you have any feedback to share please post a comment or send us an email.

Posted at 05:03 PM in AutoCAD, AutoCAD .NET, Drawing structure, Plugin of the Month, User interface | Permalink | Comments (1)

August 31, 2009

Gluing a point to an AutoCAD curve using overrules from .NET – Part 3

In the most recent part of this series, we looked at one possible mechanism to allow points to be moved along a network of curves, extending the first part in this series, which focused on the case of a point on a single curve.

This post is going to focus on something slightly different: it’s going to look at making the points added to a particular curve be associative to that curve – i.e. travel along with it as the curve is moved – and in the process we’re going to adjust the way we link between our objects, by moving the information into an object’s Extended Entity Data (XData). This does a few things: firstly it breaks our network-related technique (never fear – we’ll be able to get it back, in due course :-) by removing the idea of a central list of curves. It also allows us to have points that are connected to curves, and points that are not (which is clearly desirable). It also lays a more solid foundation for other operations, such as erasing the points on a curve when the curve itself is erased. All good stuff.

Just to be clear: there are lots of ways ways to approach this problem – this is just another possible mechanism – so you might be interested in checking out this previous series, which addressed a similar problem a little differently.

For now let’s see this basic implementation of our XData-related code. Here’s the C# code:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.Runtime;
 
namespace PointOnCurveTest
{
  public class LinkApplication
  {
    static string regAppName = "TTIF_PTS";
 
    public class LinkTransOverrule : TransformOverrule
    {
      static bool _transforming = false;
 
      // A static pointer to our overrule instance
 
      static public LinkTransOverrule theOverrule =
        new LinkTransOverrule();
 
      // A flag to indicate whether we're overruling
 
      static private bool overruling = false;
 
      // Our overrule should only be applied to objects
      // carrying our XData
 
      public LinkTransOverrule()
      {
        SetXDataFilter(regAppName);
      }
 
      // Turn on the transform overrule if it isn't already
 
      public static void TurnOn()
      {
        if (!overruling)
        {
          ObjectOverrule.AddOverrule(
            RXClass.GetClass(typeof(Entity)),
            LinkTransOverrule.theOverrule,
            true
          );
          overruling = true;
          TransformOverrule.Overruling = true;
        }
      }
 
      // Turn off the transform overrule if it's on
 
      public static void TurnOff()
      {
        if (overruling)
        {
          ObjectOverrule.RemoveOverrule(
            RXClass.GetClass(typeof(Entity)),
            LinkTransOverrule.theOverrule
          );
          overruling = false;
          TransformOverrule.Overruling = false;
        }
      }
 
      // Our primary overruled function
 
      public override void TransformBy(Entity e, Matrix3d mat)
      {
        // If we're already transforming, don't re-enter, just
        // super-message to the base
 
        if (_transforming)
          base.TransformBy(e, mat);
        else
        {
          Database db = HostApplicationServices.WorkingDatabase;
 
          // Otherwise get our linked objects: check whether
          // there are any
 
          ObjectIdCollection ids = GetLinkedObjects(e);
          if (ids.Count > 0)
          {
            // If we're dealing with a point...
 
            DBPoint pt = e as DBPoint;
            if (pt != null)
            {
              // Work through the curves to find the closest to our
              // transformed point
 
              double min = 0.0;
              Point3d bestPt = Point3d.Origin;
              bool first = true;
              ObjectId bestId = ObjectId.Null;
 
              // We're using an Open/Close transaction, to avoid
              // problems with us using transactions in an event
              // handler
 
              OpenCloseTransaction tr =
                db.TransactionManager.StartOpenCloseTransaction();
              using (tr)
              {
                // For now linked objects can be curves, else
                // they'll be ignored
 
                Curve cur;
                foreach (ObjectId curId in ids)
                {
                  DBObject obj =
                    tr.GetObject(curId, OpenMode.ForRead, true);
 
                  // If our linked object was erased, remove it
                  // from this object's links
 
                  if (obj.IsErased)
                  {
                    RemoveLinkedObject(e, curId);
                  }
                  else
                  {
                    // Otherwise we get the closest point on it
                    // to our point, to compare with others
 
                    cur = obj as Curve;
                    if (cur != null)
                    {
                      Point3d ptLoc =
                        pt.Position.TransformBy(mat);
                      Point3d ptOnCurve =
                        cur.GetClosestPointTo(ptLoc, false);
                      Vector3d dist = ptOnCurve - ptLoc;
 
                      if (first || dist.Length < min)
                      {
                        first = false;
                        min = dist.Length;
                        bestPt = ptOnCurve;
                        bestId = curId;
                      }
                    }
                  }
                }
 
                // If we didn't find a point, super-message
                // (will transform the point as normal)
 
                if (first)
                  base.TransformBy(e, mat);
                else
                  pt.Position = bestPt;
              }
            }
 
            if (e is Curve)
            {
              // Automatically super-message: we're not changing the
              // transform behaviour of the curve, only of the
              // linked objects
 
              base.TransformBy(e, mat);
 
              // Get each linked object and transform it along with
              // the "parent"
 
              OpenCloseTransaction tr =
                db.TransactionManager.StartOpenCloseTransaction();
              using (tr)
              {
                foreach (ObjectId id in ids)
                {
                  DBObject obj = tr.GetObject(id, OpenMode.ForWrite);
                  Entity ent = obj as Entity;
 
                  if (ent != null)
                  {
                    _transforming = true;
                    ent.TransformBy(mat);
                    _transforming = false;
                  }
                }
                tr.Commit();
              }
            }
          }
        }
      }
    }
 
    // Function to add a reference between one object and another
    // (stored in an object's XData)
 
    public static void AddLinkedObject(DBObject obj, ObjectId id)
    {
      Database db =
        HostApplicationServices.WorkingDatabase;
 
      // First we need to make sure our application name is
      // in the Registered Application Table
 
      OpenCloseTransaction tr =
        db.TransactionManager.StartOpenCloseTransaction();
      using (tr)
      {
        RegAppTable rat =
          (RegAppTable)tr.GetObject(
            db.RegAppTableId, OpenMode.ForRead
          );
        if (!rat.Has(regAppName))
        {
          rat.UpgradeOpen();
          RegAppTableRecord ratr =
            new RegAppTableRecord();
          ratr.Name = regAppName;
          tr.AddNewlyCreatedDBObject(ratr, true);
          rat.Add(ratr);
        }
        tr.Commit();
      }
 
      // Get our object's current XData
 
      ResultBuffer rb = obj.XData;
 
      // Check the XData, to see whether our link already exists
 
      bool foundLink = false;
 
      if (rb != null)
      {
        bool foundStart = false;
 
        foreach (TypedValue tv in rb)
        {
          // The first TypedValue is our application name
 
          if (tv.TypeCode ==
              (int)DxfCode.ExtendedDataRegAppName &&
              tv.Value.ToString() == regAppName)
            foundStart = true;
          else
          {
            if (foundStart)
            {
              // Our links will all have the same code (1005)
 
              if (tv.TypeCode == (int)DxfCode.ExtendedDataHandle)
              {
                if (id.Handle.ToString() == tv.Value.ToString())
                  foundLink = true;
              }
            }
          }
        }
      }
 
      // If we didn't find the link, add it
 
      if (!foundLink)
      {
        // This is our link
 
        TypedValue tv2 =
          new TypedValue(
            (int)DxfCode.ExtendedDataHandle, id.Handle
          );
 
        // If there was no previous XData, create the ResultBuffer
 
        if (rb == null)
        {
          rb =
            new ResultBuffer(
              new TypedValue(
                (int)DxfCode.ExtendedDataRegAppName,
                regAppName
              ),
              tv2
            );
        }
        else
        {
          // Add our TypeValue to an existing ResultBuffer
 
          rb.Add(tv2);
        }
 
        // Set the XData on our object
 
        obj.XData = rb;
      }
      rb.Dispose();
    }
 
    // Function to remove a reference from one object to another
    // (stored in an object's XData)
 
    public static void RemoveLinkedObject(DBObject obj, ObjectId id)
    {
      // Get the existing XData
 
      ResultBuffer oldRb = obj.XData;
 
      // Create a ResultBuffer for the "filtered" XData
      // (will contain all the old links, except the one we want
      // to remove)
 
      ResultBuffer newRb =
        new ResultBuffer(
          new TypedValue(
            (int)DxfCode.ExtendedDataRegAppName,
            regAppName)
          );
 
      bool foundLink = false;
 
      if (oldRb != null)
      {
        bool foundStart = false;
 
        // Loop through the XData
 
        foreach (TypedValue tv in oldRb)
        {
          // The first TypedValue is our application name
 
          if (tv.TypeCode ==
              (int)DxfCode.ExtendedDataRegAppName &&
              tv.Value.ToString() == regAppName)
            foundStart = true;
          else
          {
            if (foundStart)
            {
              // Our links will all have the same code (1005)
 
              if (tv.TypeCode == (int)DxfCode.ExtendedDataHandle)
              {
                // If the link is not the one we want to remove,
                // add it to our list of XData to retain,
                // otherwise set a flag to say we found it
 
                if (id.Handle.ToString() != tv.Value.ToString())
                  newRb.Add(tv);
                else
                  foundLink = true;
              }
            }
          }
        }
      }
 
      // If we found the link (and therefore have XData to set)
      // change the object's XData
 
      if (foundLink)
        obj.XData = newRb;
 
      // Clean-up after ourselves
 
      oldRb.Dispose();
      newRb.Dispose();
    }
 
    // Function to retrieve the references from one object to another
    // (stored in an object's XData)
 
    public static ObjectIdCollection GetLinkedObjects(DBObject obj)
    {
      Database db =
        HostApplicationServices.WorkingDatabase;
 
      // Will return an ObjectIdCollection
 
      ObjectIdCollection ids = new ObjectIdCollection();
 
      // Get the object's XData
 
      using (ResultBuffer rb = obj.XData)
      {
        if (rb != null)
        {
          bool foundStart = false;
 
          foreach (TypedValue tv in rb)
          {
            // The first TypedValue is our application name
 
            if (tv.TypeCode ==
                (int)DxfCode.ExtendedDataRegAppName &&
                tv.Value.ToString() == regAppName)
              foundStart = true;
            else
            {
              if (foundStart)
              {
                // Our links will all have the same code (1005)
 
                if (tv.TypeCode == (int)DxfCode.ExtendedDataHandle)
                {
                  // Get the long integer from the string stored in
                  // our XData, and the Handle from the long
 
                  long lg =
                    System.Convert.ToInt64(tv.Value.ToString(), 16);
                  Handle hd = new Handle(lg);
 
                  // And then the ObjectId from the Handle
 
                  ObjectId id = db.GetObjectId(false, hd, -1);
 
                  // Add it to our list, if it isn't already in it
 
                  if (!ids.Contains(id))
                    ids.Add(id);
                }
              }
            }
          }
        }
      }
      return ids;
    }
 
    [CommandMethod("POC")]
    public void CreatePointOnCurve()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Database db = doc.Database;
      Editor ed = doc.Editor;
 
      // Ask the user to select a curve
 
      PromptEntityOptions opts =
      new PromptEntityOptions(
        "\nSelect curve at the point to create: "
      );
      opts.SetRejectMessage(
        "\nEntity must be a curve."
      );
      opts.AddAllowedClass(typeof(Curve), false);
 
      PromptEntityResult per = ed.GetEntity(opts);
 
      ObjectId curId = per.ObjectId;
      if (curId != ObjectId.Null)
      {
        // Let's make sure we'll be able to see our point
 
        db.Pdmode = 97;  // square with a circle
        db.Pdsize = -10; // relative to the viewport size
 
        Transaction tr =
          doc.TransactionManager.StartTransaction();
        using (tr)
        {
          DBObject obj =
            tr.GetObject(curId, OpenMode.ForRead);
          Curve cur = obj as Curve;
          if (cur != null)
          {
            // Our initial point should be the closest point
            // on the curve to the one picked
 
            Point3d pos =
              cur.GetClosestPointTo(per.PickedPoint, false);
            DBPoint pt = new DBPoint(pos);
 
            // Add it to the same space as the curve
 
            BlockTableRecord btr =
              (BlockTableRecord)tr.GetObject(
                cur.BlockId,
                OpenMode.ForWrite
              );
            ObjectId ptId = btr.AppendEntity(pt);
            AddLinkedObject(pt, curId);
            cur.UpgradeOpen();
            AddLinkedObject(cur, ptId);
            tr.AddNewlyCreatedDBObject(pt, true);
          }
          tr.Commit();
 
          LinkTransOverrule.TurnOn();
        }
      }
    }
  }
}

Some points to note about this implementation:

We now register the overrule to work for all entity types, but at the same time we tell AutoCAD to filter on our Register Application Name
- Only objects with our XData will cause the overrule to be called
Our TransformBy() function will therefore apply to all entities with our XData, although we’re only (currently) interested in DBPoints and Curves
- We do need to stop the function re-entering for the points we transform along with the parent curve, but that’s a simple matter of setting/checking a boolean flag
We have kept the technique of checking a number of curves, to see which is closest, but as we’re only adding the XData during the POC command – which currently only allows selection of a single curve – the behaviour is now once again similar to the first post in the series (although this is very easy to change)

Now let’s see what happens when our code is executed. We’ll take the same drawing as last time – which contains a Spline and a Polyline – and use the POC command to add a few points on each:

When we move the Spline, we see the points on it now move along with it:

What’s interesting is that when we do the same for a Polyline, the points don’t appear during the drag…

… but they do, indeed, show up in the right place once the Polyline has completed the move to its destination:

This is apparently due to optimization inside AutoCAD: during a recent discussion with our Engineering team I learned that during certain operations – such as when a modification to an object or set of objects can be represented by a standard transformation (such as scale, rotate or move) – AutoCAD captures the graphics of those objects and then performs a “sprite” optimization to move the object(s), rather than continually asking the object(s) to participate in the movement by drawing their own graphics or by transforming their internal state.

It’s not fully clear to me why this is happening in this particular situation – and with the Polyline rather than the Spline – but it does appear that this optimization has been turned on during the movement of the Polyline. This only occurs in very specific situations – such as in 3D rather than 2D – but it does seem something that would be valuable for applications to have more explicit control over.

That’s it for today’s post. I’m actually on vacation this week, but I do have something to share later in the week related to our “Plugin on the Month” initiative…

Posted at 11:27 PM in AutoCAD, AutoCAD .NET, Drawing structure, Geometry, Overrules | Permalink | Comments (0) | TrackBack (0)

May 18, 2009

Importing AutoCAD layers from xrefs using .NET

This post extends the last one which looked at a basic implementation to allow AutoCAD’s standard OFFSET command to work on the contents of external references. I haven’t flagged the specific changes, but the old code (which is almost identical to that in the last post) starts with the Initialize() function.

The previous example created geometry on a temporary layer that exists only as long as the source xref is attached: detaching the xref generally caused dangling layer references. This post evolves the approach and provides a choice to the user (via the XOFFSETLAYER command): to either create the geometry on the current layer (the default behaviour) or to clone across the layers, plus their various linetypes etc., needed for the geometry to survive independently of their originating xref.

I decided to put the code to copy across the layers in a separate command called XOFFSETCPLAYS, which has the advantage of being callable separately from our OFFSET routine (and is generally a bit safer – performing significant operations on AutoCAD databases from event handlers can lead to problems, depending on what exactly you’re doing). The command gets called using SendStringToExecute() so that it gets executed up after control has returned to the AutoCAD application.

The copying of symbol table records from xrefs is a little involved, but I’ve don what I can to comment the approach below. Using Database.wblockCloneObjects() is the cleanest approach, but there is work involved to load the xrefed DWGs into their own Database objects before using this.

Here’s the updated C# code:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
using System.Collections.Generic;
 
namespace XrefOffset
{
  public class XrefOffsetApplication : IExtensionApplication
  {
    // Maintain a list of temporary objects that require removal
 
    ObjectIdCollection _ids;
    static bool _placeOnCurrentLayer = true;
 
    public XrefOffsetApplication()
    {
      _ids = new ObjectIdCollection();
    }
 
    [CommandMethod("XOFFSETLAYER")]
    static public void XrefOffsetLayer()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Database db = doc.Database;
      Editor ed = doc.Editor;
 
      PromptKeywordOptions pko =
        new PromptKeywordOptions(
          "\nEnter layer option for offset objects"
        );
      const string option1 = "Current";
      const string option2 = "Source";
 
      pko.AllowNone = true;
      pko.Keywords.Add(option1);
      pko.Keywords.Add(option2);
      pko.Keywords.Default =
        (_placeOnCurrentLayer ? option1 : option2);
 
      PromptResult pkr =
        ed.GetKeywords(pko);
 
      if (pkr.Status == PromptStatus.OK)
        _placeOnCurrentLayer =
          (pkr.StringResult == option1);
    }
 
    [CommandMethod("XOFFSETCPLAYS")]
    static public void XrefOffsetCopyLayers()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Database db = doc.Database;
      Editor ed = doc.Editor;
 
      Transaction tr =
        doc.TransactionManager.StartTransaction();
      using (tr)
      {
        BlockTableRecord btr =
          (BlockTableRecord)tr.GetObject(
            db.CurrentSpaceId,
            OpenMode.ForRead
          );
 
        // We will collect the layers used by the various entities
 
        List<string> layerNames =
          new List<string>();
 
        // And store a list of the entities to come back and update
 
        ObjectIdCollection entsToUpdate =
          new ObjectIdCollection();
 
        // Loop through the contents of the active space, and look
        // for entities that are on dependent layers (i.e. ones
        // that come from attached xrefs)
 
        foreach (ObjectId entId in btr)
        {
          Entity ent =
            (Entity)tr.GetObject(entId, OpenMode.ForRead);
 
          // Check the dependent status of the entity's layer
 
          LayerTableRecord ltr =
            (LayerTableRecord)tr.GetObject(
              ent.LayerId,
              OpenMode.ForRead
            );
 
          if (ltr.IsDependent && !(ent is BlockReference))
          {
            // Add it to our list and flag the entity for updating
 
            string layName = ltr.Name;
            if (!layerNames.Contains(layName))
            {
              layerNames.Add(layName);
            }
            entsToUpdate.Add(ent.ObjectId);
          }
        }
        // Sorting the list will allow us to minimise the number
        // of external drawings we need to load (many layers
        // will be from the same xref)
 
        layerNames.Sort();
 
        // Get the xref graph, which allows us to get at the
        // names of the xrefed drawings more easily
 
        XrefGraph xg = db.GetHostDwgXrefGraph(false);
 
        // We're going to store a list of our xrefed databases
        // for later disposal
 
        List<Database> xrefs =
          new List<Database>();
 
        // Collect a list of the layers we want to clone across
 
        ObjectIdCollection laysToClone =
          new ObjectIdCollection();
 
        // Loop through the list of layers, only loading xrefs
        // in when they haven't been already
 
        string currentXrefName = "";
        foreach(string layName in layerNames)
        {
          Database xdb = null;
 
          // Make sure we have our mangled layer name
 
          if (layName.Contains("|"))
          {
            // Split it up, so we know the xref name
            // and the root layer name
 
            int sepIdx = layName.IndexOf("|");
            string xrefName =
              layName.Substring(0, sepIdx);
            string rootName =
              layName.Substring(sepIdx + 1);
 
            // If the xref is the same as the last loaded,
            // this saves us some effort
 
            if (xrefName == currentXrefName)
            {
              xdb = xrefs[xrefs.Count-1];
            }
            else
            {
              // Otherwise we get the node for our xref,
              // so we can get its filename
 
              XrefGraphNode xgn =
                xg.GetXrefNode(xrefName);
 
              if (xgn != null)
              {
                // Create an xrefed database, loading our
                // drawing into it
 
                xdb = new Database(false, true);
                xdb.ReadDwgFile(
                  xgn.Database.Filename,
                  System.IO.FileShare.Read,
                  true,
                  null
                );
 
                // Add it to the list for later disposal
                // (we do this after the clone operation)
 
                xrefs.Add(xdb);
              }
              xgn.Dispose();
            }
 
            if (xdb != null)
            {
              // Start a transaction in our loaded database
              // to get at the layer name
 
              Transaction tr2 =
                xdb.TransactionManager.StartTransaction();
              using (tr2)
              {
                // Open the layer table
 
                LayerTable lt2 =
                  (LayerTable)tr2.GetObject(
                    xdb.LayerTableId,
                    OpenMode.ForRead
                  );
 
                // Add our layer (which we get via its
                // unmangled name) to the list to clone
 
                if (lt2.Has(rootName))
                {
                  laysToClone.Add(lt2[rootName]);
                }
 
                // Committing is cheaper
 
                tr2.Commit();
              }
            }
          }
        }
 
        // If we have layers to clone, do so
 
        if (laysToClone.Count > 0)
        {
          // We use wblockCloneObjects to clone between DWGs
 
          IdMapping idMap = new IdMapping();
          db.WblockCloneObjects(
            laysToClone,
            db.LayerTableId,
            idMap,
            DuplicateRecordCloning.Ignore,
            false
          );
 
          // Dispose each of our xrefed databases
 
          foreach (Database xdb in xrefs)
          {
            xdb.Dispose();
          }
 
          // Open the resultant layer table, so we can check
          // for the existance of our new layers
 
          LayerTable lt =
            (LayerTable)tr.GetObject(
              db.LayerTableId,
              OpenMode.ForRead
            );
 
          // Loop through the entities to update
 
          foreach (ObjectId id in entsToUpdate)
          {
            // Open them each for write, and then check their
            // current layer
 
            Entity ent =
              (Entity)tr.GetObject(id, OpenMode.ForWrite);
            LayerTableRecord ltr =
              (LayerTableRecord)tr.GetObject(
                ent.LayerId,
                OpenMode.ForRead
              );
 
            // We split the name once again (could use a function
            // for this, but hey)
 
            string layName = ltr.Name;
            int sepIdx = layName.IndexOf("|");
            string xrefName =
              layName.Substring(0, sepIdx);
            string rootName =
              layName.Substring(sepIdx + 1);
 
            // If we now have the layer in our database, use it
 
            if (lt.Has(rootName))
              ent.LayerId = lt[rootName];
          }
        }
        tr.Commit();
      }
    }
 
    public void Initialize()
    {
      DocumentCollection dm =
        Application.DocumentManager;
 
      // Remove any temporary objects at the end of the command
 
      dm.DocumentLockModeWillChange +=
        delegate(
          object sender, DocumentLockModeWillChangeEventArgs e
        )
        {
          if (_ids.Count > 0)
          {
            Transaction tr =
              e.Document.TransactionManager.StartTransaction();
            using (tr)
            {
              foreach (ObjectId id in _ids)
              {
                DBObject obj =
                  tr.GetObject(id, OpenMode.ForWrite, true);
                obj.Erase();
              }
              tr.Commit();
            }
            _ids.Clear();
 
            // Launch a command to bring across our layers
 
            if (!_placeOnCurrentLayer)
            {
              e.Document.SendStringToExecute(
                "_.XOFFSETCPLAYS ", false, false, false
              );
            }
          }
        };
 
      // When a document is created, make sure we handle the
      // important events it fires
 
      dm.DocumentCreated +=
        delegate(
          object sender, DocumentCollectionEventArgs e
        )
        {
          e.Document.CommandWillStart +=
            new CommandEventHandler(OnCommandWillStart);
          e.Document.CommandEnded +=
            new CommandEventHandler(OnCommandFinished);
          e.Document.CommandCancelled +=
            new CommandEventHandler(OnCommandFinished);
          e.Document.CommandFailed +=
            new CommandEventHandler(OnCommandFinished);
        };
 
      // Do the same for any documents existing on application
      // initialization
 
      foreach (Document doc in dm)
      {
        doc.CommandWillStart +=
          new CommandEventHandler(OnCommandWillStart);
        doc.CommandEnded +=
          new CommandEventHandler(OnCommandFinished);
        doc.CommandCancelled +=
          new CommandEventHandler(OnCommandFinished);
        doc.CommandFailed +=
          new CommandEventHandler(OnCommandFinished);
      }
    }
 
    // When the OFFSET command starts, let's add our selection
    // manipulating event-handler
 
    void OnCommandWillStart(object sender, CommandEventArgs e)
    {
      if (e.GlobalCommandName == "OFFSET")
      {
        Document doc = (Document)sender;
        doc.Editor.PromptForEntityEnding +=
          new PromptForEntityEndingEventHandler(
            OnPromptForEntityEnding
          );
      }
    }
 
    // And when the command ends, remove it
 
    void OnCommandFinished(object sender, CommandEventArgs e)
    {
      if (e.GlobalCommandName == "OFFSET")
      {
        Document doc = (Document)sender;
        doc.Editor.PromptForEntityEnding -=
          new PromptForEntityEndingEventHandler(
            OnPromptForEntityEnding
          );
      }
    }
 
    // Here's where the heavy lifting happens...
 
    void OnPromptForEntityEnding(
      object sender, PromptForEntityEndingEventArgs e
    )
    {
      if (e.Result.Status == PromptStatus.OK)
      {
        Editor ed = sender as Editor;
        ObjectId objId = e.Result.ObjectId;
        Database db = objId.Database;
 
        Transaction tr =
          db.TransactionManager.StartTransaction();
        using (tr)
        {
          // First get the currently selected object
          // and check whether it's a block reference
 
          BlockReference br =
            tr.GetObject(objId, OpenMode.ForRead)
              as BlockReference;
          if (br != null)
          {
            // If so, we check whether the block table record
            // to which it refers is actually from an XRef
 
            ObjectId btrId = br.BlockTableRecord;
            BlockTableRecord btr =
              tr.GetObject(btrId, OpenMode.ForRead)
                as BlockTableRecord;
            if (btr != null)
            {
              if (btr.IsFromExternalReference)
              {
                // If so, then we programmatically select the object
                // underneath the pick-point already used
 
                PromptNestedEntityOptions pneo =
                  new PromptNestedEntityOptions("");
                pneo.NonInteractivePickPoint =
                  e.Result.PickedPoint;
                pneo.UseNonInteractivePickPoint = true;
 
                PromptNestedEntityResult pner =
                  ed.GetNestedEntity(pneo);
 
                if (pner.Status == PromptStatus.OK)
                {
                  try
                  {
                    ObjectId selId = pner.ObjectId;
 
                    // Let's look at this programmatically-selected
                    // object, to see what it is
 
                    DBObject obj =
                      tr.GetObject(selId, OpenMode.ForRead);
 
                    // If it's a polyline vertex, we need to go one
                    // level up to the polyline itself
 
                    if (obj is PolylineVertex3d || obj is Vertex2d)
                      selId = obj.OwnerId;
 
                    // We don't want to do anything at all for
                    // textual stuff, let's also make sure we
                    // are dealing with an entity (should always
                    // be the case)
 
                    if (obj is MText || obj is DBText ||
                      !(obj is Entity))
                      return;
 
                    // Now let's get the name of the layer, to use
                    // later
 
                    Entity ent = (Entity)obj;
                    LayerTableRecord ltr =
                      (LayerTableRecord)tr.GetObject(
                        ent.LayerId,
                        OpenMode.ForRead
                      );
                    string layName = ltr.Name;
 
                    // Clone the selected object
 
                    object o = ent.Clone();
                    Entity clone = o as Entity;
 
                    // We need to manipulate the clone to make sure
                    // it works
 
                    if (clone != null)
                    {
                      // Setting the properties from the block
                      // reference helps certain entities get the
                      // right references (and allows them to be
                      // offset properly)
 
                      clone.SetPropertiesFrom(br);
 
                      // But we then need to get the layer
                      // information from the database to set the
                      // right layer (at least) on the new entity
 
                      if (_placeOnCurrentLayer)
                      {
                        clone.LayerId = db.Clayer;
                      }
                      else
                      {
                        LayerTable lt =
                          (LayerTable)tr.GetObject(
                            db.LayerTableId,
                            OpenMode.ForRead
                          );
                        if (lt.Has(layName))
                          clone.LayerId = lt[layName];
                      }
 
                      // Now we need to transform the entity for
                      // each of its Xref block reference containers
                      // If we don't do this then entities in nested
                      // Xrefs may end up in the wrong place
 
                      ObjectId[] conts =
                        pner.GetContainers();
                      foreach (ObjectId contId in conts)
                      {
                        BlockReference cont =
                          tr.GetObject(contId, OpenMode.ForRead)
                            as BlockReference;
                        if (cont != null)
                          clone.TransformBy(cont.BlockTransform);
                      }
 
                      // Let's add the cloned entity to the current
                      // space
 
                      BlockTableRecord space =
                        tr.GetObject(
                          db.CurrentSpaceId,
                          OpenMode.ForWrite
                        ) as BlockTableRecord;
                      if (space == null)
                      {
                        clone.Dispose();
                        return;
                      }
 
                      ObjectId cloneId = space.AppendEntity(clone);
                      tr.AddNewlyCreatedDBObject(clone, true);
 
                      // Now let's flush the graphics, to help our
                      // clone get displayed
 
                      tr.TransactionManager.QueueForGraphicsFlush();
 
                      // And we add our cloned entity to the list
                      // for deletion
 
                      _ids.Add(cloneId);
 
                      // Created a non-graphical selection of our
                      // newly created object and replace it with
                      // the selection of the container Xref
 
                      SelectedObject so =
                        new SelectedObject(
                          cloneId,
                          SelectionMethod.NonGraphical,
                          -1
                        );
 
                      e.ReplaceSelectedObject(so);
                    }
                  }
                  catch
                  {
                    // A number of innocuous things could go wrong
                    // so let's not worry about the details
 
                    // In the worst case we are simply not trying
                    // to replace the entity, so OFFSET will just
                    // reject the selected Xref
                  }
                }
              }
            }
          }
          tr.Commit();
        }
      }
    }
 
    public void Terminate()
    {
    }
  }
}

Depending on the mode selected, the results should be comparable with those from the code in the last post.

Here’s a portion of an xref:

Here are the results of using OFFSET on some of the xref’s contents after loading our module (to get these results you would also need to use XOFFSETLAYER to make sure the original layers get copied across):

Update:

I’ve modified the implementation of the XOFFSETLAYER command to be consistent with the prompts in the OFFSET command (under the Layer option – not sure how I missed that one :-). The ideal would have been to access that setting directly, but that doesn’t seem to be possible, as far as I can tell.

Posted at 09:06 PM in AutoCAD, AutoCAD .NET, Blocks, Commands, Drawing structure | Permalink | Comments (4) | TrackBack (0)

July 09, 2008

Testing whether an AutoCAD drawing is 2D or 3D using .NET

This post demonstrates a simple check for whether a drawing is two or three dimensional. The code is almost embarrassingly simple, but then the question is significant and in the absence of a "Is3D" property on the Database object this is likely to prove useful for people.

So how do we check whether a drawing is 3D? The quick answer is that in most circumstances the EXTMAX system variable will have a non-zero Z value for a 3D drawing. There are potential situations where this might not be true (and EXTMAX doesn't reflect the 3D nature of certain geometry), but given the likelihood that any real-world 3D model includes a variety of geometry, it's pretty safe to rely upon. The alternative is to iterate through and test geometry, but checking EXTMAX is quicker, by far, and the alternative should only by needed if you find a particular scenario that EXTMAX doesn't address.

Here's some C# code that tells us whether a drawing is 2D or 3D:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.Runtime;

namespace NumberOfDimensions
{
  public class Commands
  {
    [CommandMethod("IS3D")]
    static public void CheckWhether3D()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Database db = doc.Database;
      Editor ed = doc.Editor;

      ed.WriteMessage(
        "\nDrawing is {0}.",
        (IsDrawing3D(db) ? "3D" : "2D")
      );
    }

    private static bool IsDrawing3D(Database db)
    {
      return (db.Extmax.Z > Tolerance.Global.EqualPoint);
    }
  }
}

Here's what happens when we call the IS3D command on a fresh drawing, after we've drawn a 2D line and then after we've drawn a tiny sphere:

Command: IS3D
Drawing is 2D.
Command: LINE
Specify first point: 0,0,0
Specify next point or [Undo]: @10,10
Specify next point or [Undo]:
Command: IS3D
Drawing is 2D.
Command: SPHERE
Specify center point or [3P/2P/Ttr]: 0,0,0
Specify radius or [Diameter]: 0.0001
Command: IS3D
Drawing is 3D.

Posted at 03:58 PM in AutoCAD, AutoCAD .NET, Drawing structure, Solid modeling | Permalink | Comments (6) | TrackBack (0)

July 07, 2008

Swapping identities of AutoCAD objects using .NET

Everything aches after a very enjoyable soccer tournament in Prague (to which I mentioned I was heading off in my last post). But it was well worth the pain; it was really a lot of fun playing with and against (and just catching up with) so many friends and colleagues.

I received this question a week or so ago by email:

Is there any way to change the handle of an object through the API? Ideally I would like to select two objects and swap the handle.

The code in this post does just that: it asks the user to select two entities, and then swaps their identities (their Handles and ObjectIds), printing some "before & after" information to prove something actually happened.

A quick reminder... please feel free to send through interesting topics by email, but I must stress that these requests will be looked upon only as potential material for blog posts: if you need support related to a specific problem within a particular timeframe, please make use of the public discussion groups or submit your question via the ADN website, if you're a member. In case you're wondering why I'm not available to answer all your questions - something I often wish I could do - I should probably point out that I have a "day job" (managing the worldwide DevTech team) in addition to the time I spend blogging. There simply aren't enough hours in the day for me to do everything, however sad that makes me.

[By the way... if you're not an Autodesk Developer Network member, I do recommend joining if you have a strong need for API support: my team provides API support of a very high quality (something we measure through satisfaction surveys, etc.) and - assuming you value timely, quality support - this and the other program benefits should more than justify the cost. And ADN is not just for developers of commercial software: an increasing number of customers (and consultants implementing software specifically for customers) are joining the program.]

Anyway - back to the topic at hand... at the root of the below code is a single API call: DBObject.SwapIdWith(). Here's what the AutoCAD .NET documentation (found in the ObjectARX SDK, for now), says about the SwapIdWith() function:

This function swaps objectIds and handles between the object specified by otherId and the object invoking this function. Both objects must currently be database-resident and must reside in the same database. If swapExtendedData is true, then the objects swap extended entity data as well. If swapExtensionDictionary is true, then the objects swap extension dictionaries also.

So this function does exactly what was asked: all we then need to do is wrap it up with some code to select the entities and dump their identities to the command-line/text-screen.

Here's the C# code:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;

namespace ObjectIdentity
{
  public class Commands
  {
    [CommandMethod("SE")]
    static public void SwapEntities()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Editor ed = doc.Editor;

      PromptEntityResult per =
        ed.GetEntity("\nSelect first entity: ");
      if (per.Status != PromptStatus.OK)
        return;

      ObjectId firstId = per.ObjectId;

      per = ed.GetEntity("\nSelect second entity: ");
      if (per.Status != PromptStatus.OK)
        return;

      ObjectId secondId = per.ObjectId;

      Transaction tr =
        doc.Database.TransactionManager.StartTransaction();
      using (tr)
      {
        DBObject firstObj =
          tr.GetObject(firstId, OpenMode.ForRead);

        DBObject secondObj =
          tr.GetObject(secondId, OpenMode.ForRead);

        PrintIdentities(firstObj, secondObj);

        PromptKeywordOptions pko =
          new PromptKeywordOptions(
            "\nSwap their identities?"
          );
        pko.AllowNone = true;
        pko.Keywords.Add("Yes");
        pko.Keywords.Add("No");
        pko.Keywords.Default = "No";

        PromptResult pkr =
          ed.GetKeywords(pko);

        if (pkr.StringResult == "Yes")
        {
          try
          {
            firstObj.UpgradeOpen();
            firstObj.SwapIdWith(secondId, true, true);

            PrintIdentities(firstObj, secondObj);
          }
          catch (Exception ex)
          {
            ed.WriteMessage(
              "\nCould not swap identities: " + ex.Message
            );
          }
        }
        tr.Commit();
      }
    }

    private static void PrintIdentities(
      DBObject first, DBObject second)
    {
      PrintIdentity(first, "First");
      PrintIdentity(second, "Second");
    }

    private static void PrintIdentity(
      DBObject obj, string name)
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Editor ed = doc.Editor;

      ed.WriteMessage(
        "\n{0} object, of type {1}: " +
        "ObjectId is {2}, " +
        "Handle is {3}.",
        name,
        obj.GetType().Name,
        obj.ObjectId,
        obj.Handle
      );
    }
  }
}

Here's what happens when we run the SE command, selecting a Line and a Circle that have been created in a fresh drawing:

Command: SE
Select first entity:
Select second entity:
First object, of type Line: ObjectId is (-1075825472), Handle is 178.
Second object, of type Circle: ObjectId is (-1075825464), Handle is 179.
Swap their identities? [Yes/No] <No>: Y
First object, of type Line: ObjectId is (-1075825464), Handle is 179.
Second object, of type Circle: ObjectId is (-1075825472), Handle is 178.

So you can see that the handles and object identifiers of the Circle and the Line have been swapped.

Another function you may find useful - if you care about maintaining object identity - is DBObject.HandOverTo(). This allows you to replace a Database-resident object with another, non-Database resident one, maintaining the identity (ObjectId and Handle) of the original. This is useful if you want to implement an operation that modifies an object but has an outcome that's of a different object type. For example, if you break a Circle, you may want to be left with an Arc which has the original Circle's identity. But we'll look at this type of scenario more closely in a future post.

Posted at 05:49 PM in AutoCAD, AutoCAD .NET, Drawing structure, Selection | Permalink | Comments (4) | TrackBack (0)

May 02, 2008

Finding all the AutoCAD entities on a particular layer using .NET

This question came in recently by email:

Is there a way to obtain the object IDs of all the object on a layer? I found the GetAllObjects() method of the Transaction object but it doesn't work.

That's right: GetAllObjects() will return the objects accessed via (or added to) the transaction - it has nothing to do with retrieving objects based on any particular property.

What you need to do is Editor.SelectAll(), the equivalent of acedSSGet("X") in ObjectARX and (ssget "X") in AutoLISP. You need the version where you pass in a SelectionFilter specifying the layer for which to search.

Here's some C# code doing just this, with the hard work encapsulated in a function (GetEntitiesOnLayer()) to make it easier to integrate into your code:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;

namespace EntitySelection
{
  public class Commands
  {
    [CommandMethod("EOL")]
    static public void EntitiesOnLayer()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Editor ed = doc.Editor;

      PromptResult pr =
        ed.GetString("\nEnter name of layer: ");
      if (pr.Status == PromptStatus.OK)
      {
        ObjectIdCollection ents =
          GetEntitiesOnLayer(pr.StringResult);
        ed.WriteMessage(
          "\nFound {0} entit{1} on layer {2}",
          ents.Count,
          (ents.Count == 1 ? "y" : "ies"),
          pr.StringResult
        );
      }
    }

    private static ObjectIdCollection
      GetEntitiesOnLayer(string layerName)
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Editor ed = doc.Editor;

      // Build a filter list so that only entities
      // on the specified layer are selected

      TypedValue[] tvs =
        new TypedValue[1] {
            new TypedValue(
              (int)DxfCode.LayerName,
              layerName
            )
          };
      SelectionFilter sf =
        new SelectionFilter(tvs);
      PromptSelectionResult psr =
        ed.SelectAll(sf);

      if (psr.Status == PromptStatus.OK)
        return
          new ObjectIdCollection(
            psr.Value.GetObjectIds()
          );
      else
        return new ObjectIdCollection();
    }
  }
}

Running EOL simply counts the entities on a particular layer (the following is from running in the 3D House.dwg sample drawing):

Command: EOL
Enter name of layer: A-Beam
Found 1 entity on layer A-Beam
Command: EOL
Enter name of layer: A-Concrete
Found 1 entity on layer A-Concrete
Command: EOL
Enter name of layer: Furniture
Found 14 entities on layer Furniture
Command: EOL
Enter name of layer: Legs
Found 16 entities on layer Legs

It would be straightforward to do something more than just count the results of the GetEntitiesOnLayer() function, of course, or even to adapt the function to filter on other properties.

Posted at 07:24 AM in AutoCAD, AutoCAD .NET, Drawing structure, Selection | Permalink | Comments (6) | TrackBack (0)

January 11, 2008

Understanding the properties of textual linetype segments in AutoCAD

In the last post we looked at using .NET to define complex linetypes containing text segments. In the post I admitted to not knowing specifics about the properties used to create the text segment in the linetype, and, in the meantime, an old friend took pity on me and came to the rescue. :-)

Mike Kehoe, who I've known for many years since we worked together in the Guildford office of Autodesk UK, sent me some information that I've reproduced below. Mike now works for Micro Concepts Ltd., an Autodesk reseller, developer and training centre. He originally wrote the below description in the R12/12 timeframe, but apparently most of it remains valid; and while it refers to the text string used to define a linetype in a .lin file, these are also mostly properties that are exposed via the .NET interface.

Example: Using Text within a Linetype.
A,.5,-.2,["MK",STANDARD,S=.2,R=0.0,X=-0.1,Y=-.1],-.2

The key elements for defining the TEXT are as follows:

"MK" - These are the letters that will be printed along the line.

STANDARD -This tells AutoCAD what text style to apply to the text. NB: This is optional. When no style is defined AutoCAD will use the current text style – TextStyle holds the setting for the current text style.
[Note from Kean: I found the text style to be mandatory when using the .NET interface.]
S=.2 - This is the text scaling factor. However, there are 2 options: (1) when the text style's height is 0, then S defines the height; in this case, 0.2 units; or (2) when the text style's height parameter is non-zero, the height is found by multiplying the text style's height by this number; in this case, the linetype would place the text at 20% of the height defined in the text style.

R=0.0 - This rotates the text relative to the direction of the line; e.g.: 0.0 means there is no rotation. NB: This is optional. When no rotation is defined AutoCAD will assume zero degrees. The default measurement is degrees; NB: you can use r to specify radians, g for grads, or d for degrees, such as R=150g.
[Note from Kean: just like ObjectARX, the .NET interface accepts radians for this value, in SetShapeRotationAt(). A quick reminder: 360 degrees = 2 x PI radians. So you can pass 90 degrees using "System.Math.PI / 2".]
A=0.0 - This rotates the text relative to the x-axis ("A" is short for Absolute); this ensures the text is always oriented in the same direction, no matter the direction of the line. The rotation is always performed within the text baseline and capital height. That's so that you don't get text rotated way off near the orbit of Pluto.
[Note from Kean: to use this style of rotation using .NET, you need to use SetShapeIsUcsOrientedAt() to make sure the rotation is calculated relative to the current UCS rather than the direction of the line.]
X=-0.1 - This setting moves the text just in the x-direction from the linetype definition vertex.

Y=-0.1 – This setting moves the text in the y-direction from the linetype definition vertex.
These 2 settings can be used to center the text in the line. The units are defined from the linetype scale factor, which is stored in system variable LtScale.

Thanks for the information, Mike!

Posted at 05:10 PM in AutoCAD, AutoCAD .NET, Drawing structure, Object properties | Permalink | Comments (0) | TrackBack (0)

January 09, 2008

Creating a complex AutoCAD linetype containing text using .NET

In my last post we saw some code to create a simple linetype using .NET. As a comment on that post, Mark said:

Kean, i tried you code and it works great and it also got me thinking... is it possible to programmitically add text in as well? I've tried using ltr.SetTextAt(1, "TEST") but so far i've had no luck, any suggestions???

It turned out to be quite a bit more complicated to make a linetype containing text than merely calling SetTextAt() on one of the segments. In order to understand what properties needed setting, I first loaded the HOT_WATER_SUPPLY linetype from acad.lin (using the LINETYPE command):

I then looked at the contents of the linetype table using ArxDbg (the ObjectARX SDK sample that is very helpful for understanding drawing structure). Here's what the SNOOPDB command - defined by the ArxDbg application - showed for the loaded linetype:

From there it was fairly straightforward to determine the code needed to create our own complex linetype containing text segments. I decided to call the new linetype "COLD_WATER_SUPPLY", and have it resemble the original in every way but placing "CW" in the middle segment, rather than "HW" (with the descriptions updated to match, of course). As I've simply copied the properties of an existing linetype, please don't ask me to explain what they all mean. :-)

Here's the C# code:

using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.EditorInput;

namespace Linetype
{
  public class Commands
  {
    [CommandMethod("CCL")]
    public void CreateComplexLinetype()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Database db = doc.Database;
      Editor ed = doc.Editor;

      Transaction tr =
        db.TransactionManager.StartTransaction();
      using (tr)
      {
        // We'll use the textstyle table to access
        // the "Standard" textstyle for our text
        // segment

        TextStyleTable tt =
          (TextStyleTable)tr.GetObject(
            db.TextStyleTableId,
            OpenMode.ForRead
          );

        // Get the linetype table from the drawing

        LinetypeTable lt =
          (LinetypeTable)tr.GetObject(
            db.LinetypeTableId,
            OpenMode.ForWrite
          );

        // Create our new linetype table record...

        LinetypeTableRecord ltr =
          new LinetypeTableRecord();

        // ... and set its properties

        ltr.Name = "COLD_WATER_SUPPLY";
        ltr.AsciiDescription =
          "Cold water supply ---- CW ---- CW ---- CW ----";
        ltr.PatternLength = 0.9;
        ltr.NumDashes = 3;

        // Dash #1

        ltr.SetDashLengthAt(0, 0.5);

        // Dash #2

        ltr.SetDashLengthAt(1, -0.2);
        ltr.SetShapeStyleAt(1, tt["Standard"]);
        ltr.SetShapeNumberAt(1, 0);
        ltr.SetShapeOffsetAt(1, new Vector2d(-0.1,-0.05));
        ltr.SetShapeScaleAt(1, 0.1);
        ltr.SetShapeIsUcsOrientedAt(1, false);
        ltr.SetShapeRotationAt(1, 0);
        ltr.SetTextAt(1, "CW");

        // Dash #3

        ltr.SetDashLengthAt(2, -0.2);

        // Add the new linetype to the linetype table

        ObjectId ltId = lt.Add(ltr);
        tr.AddNewlyCreatedDBObject(ltr, true);

        // Create a test line with this linetype

        BlockTable bt =
          (BlockTable)tr.GetObject(
            db.BlockTableId,
            OpenMode.ForRead
          );
        BlockTableRecord btr =
          (BlockTableRecord)tr.GetObject(
            bt[BlockTableRecord.ModelSpace],
            OpenMode.ForWrite
          );

        Line ln =
          new Line(
            new Point3d(0, 0, 0),
            new Point3d(10, 10, 0)
          );

        ln.SetDatabaseDefaults(db);
        ln.LinetypeId = ltId;

        btr.AppendEntity(ln);
        tr.AddNewlyCreatedDBObject(ln, true);

        tr.Commit();
      }
    }
  }
}

And here's the result of calling the CCL command and zooming in on the created line:

Posted at 03:28 PM in AutoCAD, AutoCAD .NET, Drawing structure, Object properties | Permalink | Comments (13) | TrackBack (0)

January 07, 2008

Creating an AutoCAD linetype programmatically using .NET

Happy New Year, everyone!

I had a very relaxing break over the holiday period: during the better part of two weeks I managed to stay away from my PC and even my BlackBerry, which I admit I'm generally not very good at ignoring. So now I'm easing back into the swing of things, remembering how to type and open modelspaces, among other things. :-)

To save my brain from unnecessary stress during the first few weeks of 2008, I've decided to take inspiration from the ADN website. Today's post is based on this DevNote, which shows how to create a custom linetype using ObjectARX.

Here's some equivalent code in C#:

using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.EditorInput;

namespace Linetype
{
  public class Commands
  {
    [CommandMethod("CL")]
    public void CreateLinetype()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Database db = doc.Database;
      Editor ed = doc.Editor;

      Transaction tr =
        db.TransactionManager.StartTransaction();
      using (tr)
      {
        // Get the linetype table from the drawing

        LinetypeTable lt =
          (LinetypeTable)tr.GetObject(
            db.LinetypeTableId,
            OpenMode.ForWrite
          );

        // Create our new linetype table record...

        LinetypeTableRecord ltr =
          new LinetypeTableRecord();

        // ... and set its properties

        ltr.AsciiDescription = "T E S T -";
        ltr.PatternLength = 0.75;
        ltr.NumDashes = 2;
        ltr.SetDashLengthAt(0, 0.5);
        ltr.SetDashLengthAt(1,-0.25);
        ltr.Name = "TESTLINTEYPE";

        // Add the new linetype to the linetype table

        ObjectId ltId = lt.Add(ltr);
        tr.AddNewlyCreatedDBObject(ltr,true);

        // Create a test line with this linetype

        BlockTable bt =
          (BlockTable)tr.GetObject(
            db.BlockTableId,
            OpenMode.ForRead
          );
        BlockTableRecord btr =
          (BlockTableRecord)tr.GetObject(
            bt[BlockTableRecord.ModelSpace],
            OpenMode.ForWrite
          );

        Line ln =
          new Line(
            new Point3d(0, 0, 0),
            new Point3d(10, 10, 0)
          );

        ln.SetDatabaseDefaults(db);
        ln.LinetypeId = ltId;

        btr.AppendEntity(ln);
        tr.AddNewlyCreatedDBObject(ln, true);

        tr.Commit();
      }
    }
  }
}

Once you've run the CL command, Zoom Extents to see a line that has been created with our new custom linetype.

Posted at 04:19 PM in AutoCAD, AutoCAD .NET, Drawing structure, Object properties | Permalink | Comments (6) | TrackBack (0)

September 10, 2007

Accessing the active space or layout in an AutoCAD drawing using .NET

This question was asked as comment to a previous post by har!s:

Thanks a lot for the code. I have yet to see 2008 and MultiLeader. But I presume that it works on both Model and paper spaces. In that case, what is the best method to make the operation space independent? i.e., it should work on active space irrespective of whether it's model or paper. I think this will be generally applicable to almost all the entity creations.

The question is very valid and does indeed apply to a lot of entity creation - and other - activities. Most of the time I simply show how to open the modelspace in my code, for example:

  Document doc =
    Application.DocumentManager.MdiActiveDocument;
  Editor ed = doc.Editor;
  Database db = doc.Database;
 
  Transaction tr =
    db.TransactionManager.StartTransaction();
  using (tr)
  {
    BlockTable bt =
      (BlockTable)tr.GetObject(
        db.BlockTableId,
        OpenMode.ForRead
      );
    BlockTableRecord btr =
      (BlockTableRecord)tr.GetObject(
        bt[BlockTableRecord.ModelSpace],
        OpenMode.ForWrite
      );
    // ...
  }

The key statement here is at the end, where we use GetObject() to open the BlockTableRecord to which we want to (for example) append an entity. The form we use is:

  bt[BlockTableRecord.ModelSpace]

Breaking this down: we're actually looking up the ObjectId of the BlockTableRecord with the name of "*MODEL_SPACE", which is the string stored in the static ModelSpace property of the BlockTableRecord class.

Here are a few different options for what we might do here:

Use either BlockTableRecord.ModelSpace or BlockTableRecord.PaperSpace, if we know that we want to access either of these containers (the current approach).
Use foreach() on the BlockTable to iterate through the various BlockTableRecords: you can open each one using GetObject() and check the IsLayout property to find those that are either modelspace or paperspace layouts.
Use db.CurrentSpaceId to open the currently active space in that particular database.

Option 3 is really the answer to this question, which makes the code like this:

  Document doc =
    Application.DocumentManager.MdiActiveDocument;
  Editor ed = doc.Editor;
  Database db = doc.Database;
 
  Transaction tr =
    db.TransactionManager.StartTransaction();
  using (tr)
  {
    BlockTable bt =
      (BlockTable)tr.GetObject(
        db.BlockTableId,
        OpenMode.ForRead
      );
    BlockTableRecord btr =
      (BlockTableRecord)tr.GetObject(
        db.CurrentSpaceId,
        OpenMode.ForWrite
      );
    // ...
  }

Posted at 07:49 PM in AutoCAD, AutoCAD .NET, Drawing structure | Permalink | Comments (2) | TrackBack (0)

Through the Interface

Kean Walmsley

November 2009

Post Index

Reverse Index

Twitter Updates

Autodesk Blogs