Through the Interface: User interface

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	31

User interface

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 (7)

October 30, 2009

Streamlined QuickSaveAs command for AutoCAD 2010

A big thanks to Tony Tanzillo for providing some tips to help improve the implementation of the application we saw in these previous posts: in particular Tony pointed out the ability of AutoCAD 2010 to generate a thumbnail image for a document in the editor programmatically (something I had forgotten was possible… at least I think I knew it existed – it certainly seemed familiar once I saw it :-S). Anyway, the version of the code in this post will only work from AutoCAD 2010 onwards because of the use of this function, Document.CapturePreviewImage().

Tony’s code also showed some interesting capabilities of the .NET Framework related to filename and path manipulation, so I also borrowed some of those techniques to avoid some ugly string parsing/manipulation.

Because of this ability to generate thumbnails – something I really wanted from the beginning – we can avoid the use of SAVEAS and simply use Document.SaveAs(), which will save a copy of the drawing without renaming the version in the editor (which in my particular situation is desirable). And clearly there’s no longer any need for a continuation function (whether or not you believe that was an appropriate way to implement the application in the first place).

Here’s the updated C# code:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.Windows.ToolPalette;
using System.Runtime.InteropServices;
using System.Drawing;
using System.IO;
using System;
 
namespace QuickSaveAs
{
  public class Commands
  {
    // Set up static variable for the path to our folder
    // of drawings, as well as the base filename and a
    // counter to make the unique filename
 
    static string _path = "",
                  _base = "";
    static int _count = 0;
 
    // Various filename and path-related constants
 
    const string sfxSep = " ",
                 pthSep = "\\",
                 lspSep = "/",
                 dwgExt = ".dwg",
                 scrExt = ".txt",
                 bmpExt = ".bmp",
                 bmpLoc = "Images",
                 scrLoc = "Scripts";
 
    // Our QuickSaveAs command
 
    [CommandMethod("QSAVEAS")]
    public void QuickSaveAs()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Editor ed = doc.Editor;
      Database db = doc.Database;
 
      // If this is the first time run...
 
      if (_path == "" || _base == "")
      {
        // Ask the user for a base file location
 
        PromptSaveFileOptions opts =
          new PromptSaveFileOptions(
            "Select location to save first drawing file"
          );
        opts.Filter = "Drawing (*.dwg)|*.dwg";
        PromptFileNameResult pr =
          ed.GetFileNameForSave(opts);
 
        if (pr.Status == PromptStatus.OK)
        {
          // If a file was selected, and it contains a path...
 
          // Separate the path from the file name
 
          _base =
            Path.GetFileNameWithoutExtension(pr.StringResult);
          _path =
            Path.GetDirectoryName(pr.StringResult);
 
          // Create folders for our icons and our scripts
 
          Directory.CreateDirectory(
            _path + pthSep + bmpLoc
          );
          Directory.CreateDirectory(
            _path + pthSep + scrLoc
          );
        }
      }
 
      // Assuming the path and name were set appropriately...
 
      if (_path != "" && _base != "")
      {
        string name = _base,
               dwgFile;
 
        // Add our suffix if not the first time run
 
        do
        {
          if (_count > 0)
            name += sfxSep + _count.ToString();
 
          // Our drawing is located in the base path
 
          dwgFile = _path + pthSep + name + dwgExt;
          _count++;
        }
        while (File.Exists(dwgFile));
 
        // While our script is in a sub-folder
 
        string scrPath =
          _path + pthSep + scrLoc + pthSep + name + scrExt;
 
        // Create a dummy script, so we can make sure we pick
        // up the contents in our dummy execute command
 
        File.WriteAllText(
          scrPath,
          "This is a dummy script for " + name + "."
        );
 
        // Now we want to save our drawing and use the image
        // for our tool icon
 
        if (!string.IsNullOrEmpty(dwgFile))
        {
          Bitmap thumb = doc.CapturePreviewImage(320, 240);
          doc.Database.ThumbnailBitmap = thumb;
 
          doc.Database.SaveAs(dwgFile, DwgVersion.Current);
          ed.WriteMessage(
            "\nCopy of current document saved to {0}",
            Path.GetFileName(dwgFile)
          );
 
          CreateCommand(thumb, name, scrPath);
        }
      }
    }
 
    // Function to add a command tool to our tool palette to
    // execute the script
 
    private void CreateCommand(
      Bitmap thumb,
      string name,
      string scrPath
    )
    {
      const string catName = "ScriptCatalog";
      const string palName = "Scripts";
 
      ToolPaletteManager tpm = ToolPaletteManager.Manager;
 
      // Get the GUID of our dummy custom tool
 
      Type t = typeof(DummyTool);
      GuidAttribute ga =
        (GuidAttribute)t.GetCustomAttributes(
          typeof(GuidAttribute), false)[0];
      Guid g = new Guid(ga.Value);
 
      // Instanciate our dummy tool - this will allow us to use
      // its helper functions
 
      DummyTool tool = new DummyTool();
      Catalog cat;
      Palette pal = null;
 
      // First we check whether our GUID is in a catalog
 
      CatalogItem ci = tpm.StockToolCatalogs.Find(g);
      if (ci != null)
      {
        // If it is, search each catalog for our palette
 
        foreach(CatalogItem ci2 in tpm.Catalogs)
        {
          for (int i = 0; i < ci2.ChildCount; i++)
          {
            CatalogItem ci3 = ci2.GetChild(i);
            if (ci3 != null && ci3.Name == palName)
            {
              pal = ci3 as Palette;
              break;
            }
          }
          if (pal != null)
            break;
        }
      }
 
      // If we didn't find our palette, create it
 
      if (pal == null)
      {
        cat = tool.CreateStockTool(catName);
        pal = tool.CreatePalette(cat, palName);
      }
 
      // To add our command tool instance we need an icon
 
      ImageInfo ii = new ImageInfo();
      if (thumb != null)
      {
        // Which we create from the Database's thumbnail
 
        string bmpPath =
          _path + pthSep + bmpLoc + pthSep + name + bmpExt;
        thumb.Save(bmpPath);
        ii.ResourceFile = bmpPath;
      }
      ii.Size = new System.Drawing.Size(65, 65);
 
      // And then we use our dummy tool to create the
      // command tool
 
      tool.CreateCommandTool(
        pal,
        name,
        ii,
        "_EXECSCR \"" + scrPath.Replace(pthSep, lspSep) + "\""
      );
 
      // Finally we reload the catalogs to display the change
 
      tpm.LoadCatalogs(
        CatalogTypeFlags.Catalog,
        LoadFlags.LoadImages
      );
    }
 
    // A dummy command to simulate the execution of our script
    // (which simply reads the contents and displays them on
    // the command-line)
 
    [CommandMethod("EXECSCR")]
    public void ExecuteScript()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Editor ed = doc.Editor;
 
      PromptResult pr =
        ed.GetString(
          "\nEnter location of script to execute: "
        );
      if (pr.Status == PromptStatus.OK)
      {
        string path =
          pr.StringResult.Replace(lspSep, pthSep);
        if (File.Exists(path))
        {
          string contents = File.ReadAllText(path);
          ed.WriteMessage(
            "\nDummy script contained: \"{0}\"",
            contents
          );
        }
      }
    }
  }
 
  // Our dummy tool which simply derives from CustomToolBase
  // (there may be a more straightforward way to get access
  // to the helpers in CustomToolBase, but anyway)
 
  [Guid("3B725500-0451-4081-A1BB-B37CE6A65767")]
  [Tool("MyDummyTool", "IDB_TOOL")]
  [ClassInterface(ClassInterfaceType.AutoDual)]
  public class DummyTool : CustomToolBase
  {
  }
}

The QSAVEAS command executes more quickly and cleanly, providing results comparable to the previous version’s:

Posted at 06:38 AM in AutoCAD, AutoCAD .NET, Commands, User interface | Permalink | Comments (3)

September 25, 2009

Clipboard Manager: October’s ADN Plugin of the Month, now live on Autodesk Labs

As Scott is leaving on a well-deserved sabbatical, he has gone ahead and posted our next Plugin of the Month a few days ahead of schedule. Here’s a link to Scott’s post announcing the tool.

This is a very cool little application developed by Mark Dubbelaar from Australia. Mark has been drafting/designing with AutoCAD for the last 10+ years and, during this time, has used a variety of programming languages to customize AutoCAD: LISP, VBA and now VB.NET. Mark was inspired by the “clipboard ring” functionality that used to be in Microsoft Office (at least I say “used to be” because I haven’t found it in Office 2007), and decided to implement similar functionality in AutoCAD.

The implementation of the tool is quite straightforward but the functionality is really very compelling: after having NETLOADed the tool and run the CLIPBOARD command, as you use Ctrl-C to copy drawing objects from inside AutoCAD to the clipboard a custom palette gets populated with entries containing these sets of objects. Each entry contains a time-stamp and an automatically-generated name which you can then change to something more meaningful.

When you want to use these clipboard entries, you simply right-click on one and choose the appropriate paste option (which ultimately just calls through to the standard AutoCAD paste commands, PASTECLIP, PASTEBLOCK and PASTEORIG, reducing the complexity of the tool).

That’s really all there is to it: a simple yet really useful application. Thanks for providing such a great little tool, Mark! :-)

Under the hood, the code is quite straightforward. The main file, Clipboard.vb, sets up the application to create demand-loading entries when first loaded into AutoCAD and defines a couple of commands – CLIPBOARD and REMOVECB, which removes the demand-loading entries to “uninstall” the application. It also contains the PaletteSet that contains our CbPalette and gets displayed by the CLIPBOARD command.

Imports Autodesk.AutoCAD.Runtime
Imports Autodesk.AutoCAD.Windows
Imports Autodesk.AutoCAD.EditorInput
 
Public Class ClipBoard
  Implements IExtensionApplication
 
  <DebuggerBrowsable(DebuggerBrowsableState.Never)> _
  Private _cp As CbPalette = Nothing
 
  Public ReadOnly Property ClipboardPalette() As CbPalette
    Get
      If _cp Is Nothing Then
        _cp = New CbPalette
      End If
      Return _cp
    End Get
  End Property
 
  Private _ps As PaletteSet = Nothing
 
  Public ReadOnly Property PaletteSet() As PaletteSet
    Get
      If _ps Is Nothing Then
        _ps = New PaletteSet("Clipboard", _
          New System.Guid("ED8CDB2B-3281-4177-99BE-E1A46C3841AD"))
        _ps.Text = "Clipboard"
        _ps.DockEnabled = DockSides.Left + _
          DockSides.Right + DockSides.None
        _ps.MinimumSize = New System.Drawing.Size(200, 300)
        _ps.Size = New System.Drawing.Size(300, 500)
        _ps.Add("Clipboard", ClipboardPalette)
      End If
      Return _ps
    End Get
  End Property
 
  Private Sub Initialize() _
    Implements IExtensionApplication.Initialize
 
    DemandLoading.RegistryUpdate.RegisterForDemandLoading()
  End Sub
 
  Private Sub Terminate() _
    Implements IExtensionApplication.Terminate
 
  End Sub
 
  <CommandMethod("ADNPLUGINS", "CLIPBOARD", CommandFlags.Modal)> _
  Public Sub ShowClipboard()
 
    PaletteSet.Visible = True
 
  End Sub
 
  <CommandMethod("ADNPLUGINS", "REMOVECB", CommandFlags.Modal)> _
  Public Sub RemoveClipboard()
 
    DemandLoading.RegistryUpdate.UnregisterForDemandLoading()
    Dim ed As Editor = _
      Autodesk.AutoCAD.ApplicationServices.Application _
      .DocumentManager.MdiActiveDocument.Editor()
    ed.WriteMessage(vbCr + _
      "The Clipboard Manager will not be loaded" _
      + " automatically in future editing sessions.")
 
  End Sub
End Class

It’s the Clipboard_Palette.vb file that contains the more interesting code, implementing the behaviour of the CbPalette object. The real “magic” is how it hooks into AutoCAD’s COPYCLIP by attaching itself as the default “clipboard viewer”.

Imports AcApp = Autodesk.AutoCAD.ApplicationServices.Application
Imports System.Windows.Forms
 
Public Class CbPalette
 
  ' Constants for Windows API calls
 
  Private Const WM_DRAWCLIPBOARD As Integer = &H308
  Private Const WM_CHANGECBCHAIN As Integer = &H30D
 
  ' Handle for next clipboard viewer
 
  Private _nxtCbVwrHWnd As IntPtr
 
  ' Boolean to control access to clipboard data
 
  Private _internalHold As Boolean = False
 
  ' Counter for our visible clipboard name
 
  Private _clipboardCounter As Integer = 0
 
  ' Windows API declarations
 
  Declare Auto Function SetClipboardViewer Lib "user32" _
    (ByVal HWnd As IntPtr) As IntPtr
  Declare Auto Function SendMessage Lib "User32" _
    (ByVal HWnd As IntPtr, ByVal Msg As Integer, _
    ByVal wParam As IntPtr, ByVal lParam As IntPtr) As Long
 
  ' Class constructor
 
  Public Sub New()
 
    ' This call is required by the Windows Form Designer
 
    InitializeComponent()
 
    ' Register ourselves to handle clipboard modifications
 
    _nxtCbVwrHWnd = SetClipboardViewer(Handle)
 
  End Sub
 
  Private Sub AddDataToGrid()
 
    Dim currentClipboardData As DataObject = _
      My.Computer.Clipboard.GetDataObject
 
    ' If the clipboard contents are AutoCAD-related
 
    If IsAutoCAD(currentClipboardData.GetFormats) Then
 
      ' Create a new row for our grid and add our clipboard
      ' data stored in the "tag"
 
      Dim newRow As New DataGridViewRow()
      newRow.Tag = currentClipboardData
 
      ' Increment our counter
 
      _clipboardCounter += 1
 
      ' Create and add a cell for the name, using our counter
 
      Dim newNameCell As New DataGridViewTextBoxCell
      newNameCell.Value = "Clipboard " & _clipboardCounter
      newRow.Cells.Add(newNameCell)
 
      ' Get the current time and place that in another cell
 
      Dim newTimeCell As New DataGridViewTextBoxCell
      newTimeCell.Value = Now.ToLongTimeString
      newRow.Cells.Add(newTimeCell)
 
      ' Add our row to the data grid and select it
 
      clipboardDataGridView.Rows.Add(newRow)
      clipboardDataGridView.FirstDisplayedScrollingRowIndex = _
        clipboardDataGridView.Rows.Count - 1
      newRow.Selected = True
 
    End If
 
  End Sub
 
  ' Move the selected item's data into the clipboard
 
  ' Check whether the clipboard data was created by AutoCAD
 
  Private Function IsAutoCAD(ByVal Formats As String()) As Boolean
 
    For Each item As String In Formats
      If item.Contains("AutoCAD") Then Return True
    Next
    Return False
 
  End Function
 
  Private Sub PasteToClipboard()
 
    ' Use a variable to make sure we don't edit the
    ' clipboard contents at the wrong time
 
    _internalHold = True
    My.Computer.Clipboard.SetDataObject( _
      clipboardDataGridView.SelectedRows.Item(0).Tag)
    _internalHold = False
 
  End Sub
 
  ' Send a command to AutoCAD
 
  Private Sub SendAutoCADCommand(ByVal cmd As String)
 
    AcApp.DocumentManager.MdiActiveDocument.SendStringToExecute( _
      cmd, True, False, True)
 
  End Sub
 
  ' Our context-menu command handlers
 
  Private Sub PasteToolStripButton_Click( _
    ByVal sender As Object, ByVal e As EventArgs) _
    Handles PasteToolStripMenuItem.Click
 
    ' Swap the data from the selected item in the grid into the
    ' clipboard and use the internal AutoCAD command to paste it
 
    If clipboardDataGridView.SelectedRows.Count = 1 Then
      PasteToClipboard()
      SendAutoCADCommand("_pasteclip ")
    End If
  End Sub
 
  Private Sub PasteAsBlockToolStripMenuItem_Click( _
    ByVal sender As Object, ByVal e As EventArgs) _
    Handles PasteAsBlockToolStripMenuItem.Click
 
    ' Swap the data from the selected item in the grid into the
    ' clipboard and use the internal AutoCAD command to paste it
    ' as a block
 
    If clipboardDataGridView.SelectedRows.Count = 1 Then
      PasteToClipboard()
      SendAutoCADCommand("_pasteblock ")
    End If
  End Sub
 
  Private Sub PasteToOriginalCoordinatesToolStripMenuItem_Click( _
    ByVal sender As Object, ByVal e As EventArgs) _
    Handles PasteToOriginalCoordinatesToolStripMenuItem.Click
 
    ' Swap the data from the selected item in the grid into the
    ' clipboard and use the internal AutoCAD command to paste it
    ' at the original location
 
    If clipboardDataGridView.SelectedRows.Count = 1 Then
      PasteToClipboard()
      SendAutoCADCommand("_pasteorig ")
    End If
  End Sub
 
  Private Sub RemoveAllToolStripButton_Click( _
    ByVal sender As Object, ByVal e As EventArgs) _
    Handles RemoveAllToolStripButton.Click
 
    ' Remove all the items in the grid
 
    clipboardDataGridView.Rows.Clear()
  End Sub
 
  Private Sub RenameToolStripMenuItem_Click( _
    ByVal sender As Object, ByVal e As EventArgs) _
    Handles RenameToolStripMenuItem.Click
 
    ' Rename the selected row by editing the name cell
 
    If clipboardDataGridView.SelectedRows.Count = 1 Then
      clipboardDataGridView.BeginEdit(True)
    End If
  End Sub
 
  Private Sub RemoveToolStripMenuItem_Click( _
    ByVal sender As Object, ByVal e As EventArgs) _
    Handles RemoveToolStripMenuItem.Click
 
    ' Remove the selected grid item
 
    If clipboardDataGridView.SelectedRows.Count = 1 Then
      clipboardDataGridView.Rows.Remove( _
        clipboardDataGridView.SelectedRows.Item(0))
    End If
  End Sub
 
  ' Our grid view event handlers
 
  Private Sub ClipboardDataGridView_CellMouseDown( _
    ByVal sender As Object, _
    ByVal e As DataGridViewCellMouseEventArgs) _
    Handles clipboardDataGridView.CellMouseDown
 
    ' Responding to this event allows us to make sure the
    ' correct row is properly selected on right-click
 
    If e.Button = Windows.Forms.MouseButtons.Right Then
      clipboardDataGridView.CurrentCell = _
        clipboardDataGridView.Item(e.ColumnIndex, e.RowIndex)
    End If
  End Sub
 
  Private Sub ClipboardDataGridView_MouseDown( _
    ByVal sender As System.Object, ByVal e As MouseEventArgs) _
    Handles clipboardDataGridView.MouseDown
 
    ' On right-click display the row as selected and show
    ' the context menu at the location of the cursor
 
    If e.Button = Windows.Forms.MouseButtons.Right Then
      Dim hti As DataGridView.HitTestInfo = _
        clipboardDataGridView.HitTest(e.X, e.Y)
      If hti.Type = DataGridViewHitTestType.Cell Then
 
        clipboardDataGridView.ClearSelection()
        clipboardDataGridView.Rows(hti.RowIndex).Selected = True
 
        ContextMenuStrip.Show(clipboardDataGridView, e.Location)
      End If
    End If
 
  End Sub
 
  ' Override WndProc to get messages
 
  Protected Overrides Sub WndProc(ByRef m As Message)
    Select Case m.Msg
 
  ' The clipboard has changed
 
  Case Is = WM_DRAWCLIPBOARD
 
    If Not _internalHold Then AddDataToGrid()
 
    SendMessage(_nxtCbVwrHWnd, m.Msg, m.WParam, m.LParam)
 
    ' Another clipboard viewer has removed itself
 
  Case Is = WM_CHANGECBCHAIN
 
    If m.WParam = CType(_nxtCbVwrHWnd, IntPtr) Then
      _nxtCbVwrHWnd = m.LParam
    Else
      SendMessage(_nxtCbVwrHWnd, m.Msg, m.WParam, m.LParam)
    End If
 
    End Select
 
    MyBase.WndProc(m)
  End Sub
 
End Class
 
Public Class PaletteToolStrip
 
  Inherits ToolStrip
 
  Public Sub New()
    MyBase.New()
  End Sub
 
  Public Sub New(ByVal ParamArray Items() As ToolStripItem)
    MyBase.New(Items)
  End Sub
 
  Protected Overrides Sub WndProc(ByRef m As Message)
    If m.Msg = &H21 AndAlso CanFocus AndAlso Not Focused Then
      Focus()
    End If
    MyBase.WndProc(m)
  End Sub
 
End Class

I also added a VB.NET version of the C# code that automatically registers an AutoCAD .NET application for demand-loading based on the commands it defines:

Imports System.Collections.Generic
Imports System.Reflection
Imports System.Resources
Imports System
Imports Microsoft.Win32
Imports Autodesk.AutoCAD.DatabaseServices
Imports Autodesk.AutoCAD.Runtime
 
Namespace DemandLoading
  Public Class RegistryUpdate
    Public Shared Sub RegisterForDemandLoading()
  ' Get the assembly, its name and location
 
  Dim assem As Assembly = Assembly.GetExecutingAssembly()
  Dim name As String = assem.GetName().Name
  Dim path As String = assem.Location
 
  ' We'll collect information on the commands
  ' (we could have used a map or a more complex
  ' container for the global and localized names
  ' - the assumption is we will have an equal
  ' number of each with possibly fewer groups)
 
  Dim globCmds As New List(Of String)()
  Dim locCmds As New List(Of String)()
  Dim groups As New List(Of String)()
 
  ' Iterate through the modules in the assembly
 
  Dim mods As [Module]() = assem.GetModules(True)
  For Each [mod] As [Module] In mods
    ' Within each module, iterate through the types
 
    Dim types As Type() = [mod].GetTypes()
    For Each type As Type In types
      ' We may need to get a type's resources
 
      Dim rm As New ResourceManager(type.FullName, assem)
      rm.IgnoreCase = True
 
      ' Get each method on a type
 
      Dim meths As MethodInfo() = type.GetMethods()
      For Each meth As MethodInfo In meths
        ' Get the methods custom command attribute(s)
 
        Dim attbs As Object() = _
          meth.GetCustomAttributes( _
        GetType(CommandMethodAttribute), True)
        For Each attb As Object In attbs
          Dim cma As CommandMethodAttribute = _
            TryCast(attb, CommandMethodAttribute)
          If cma IsNot Nothing Then
            ' And we can finally harvest the information
            ' about each command
 
            Dim globName As String = cma.GlobalName
            Dim locName As String = globName
            Dim lid As String = cma.LocalizedNameId
 
            ' If we have a localized command ID,
            ' let's look it up in our resources
 
            If lid IsNot Nothing Then
              ' Let's put a try-catch block around this
              ' Failure just means we use the global
              ' name twice (the default)
 
              Try
                locName = rm.GetString(lid)
              Catch
              End Try
            End If
 
            ' Add the information to our data structures
 
            globCmds.Add(globName)
            locCmds.Add(locName)
 
            If cma.GroupName IsNot Nothing AndAlso _
              Not groups.Contains(cma.GroupName) Then
              groups.Add(cma.GroupName)
            End If
          End If
        Next
      Next
    Next
  Next
 
  ' Let's register the application to load on demand (12)
  ' if it contains commands, otherwise we will have it
  ' load on AutoCAD startup (2)
 
  Dim flags As Integer = (If(globCmds.Count > 0, 12, 2))
 
  ' By default let's create the commands in HKCU
  ' (pass false if we want to create in HKLM)
 
  CreateDemandLoadingEntries(name, path, globCmds, locCmds, _
    groups, flags, True)
    End Sub
 
    Public Shared Sub UnregisterForDemandLoading()
      RemoveDemandLoadingEntries(True)
    End Sub
 
    ' Helper functions
 
    Private Shared Sub CreateDemandLoadingEntries( _
      ByVal name As String, ByVal path As String, _
      ByVal globCmds As List(Of String), _
      ByVal locCmds As List(Of String), _
      ByVal groups As List(Of String), _
      ByVal flags As Integer, _
      ByVal currentUser As Boolean)
 
      ' Choose a Registry hive based on the function input
 
      Dim hive As RegistryKey = _
        If(currentUser,Registry.CurrentUser,Registry.LocalMachine)
 
      ' Open the main AutoCAD (or vertical) and "Applications" keys
 
      Dim ack As RegistryKey = _
        hive.OpenSubKey( _
          HostApplicationServices.Current.RegistryProductRootKey)
      Dim appk As RegistryKey = ack.OpenSubKey("Applications", True)
 
      ' Already registered? Just return
 
      Dim subKeys As String() = appk.GetSubKeyNames()
      For Each subKey As String In subKeys
        If subKey.Equals(name) Then
          appk.Close()
          Exit Sub
        End If
      Next
 
      ' Create the our application's root key and its values
 
      Dim rk As RegistryKey = appk.CreateSubKey(name)
      rk.SetValue("DESCRIPTION", name, RegistryValueKind.[String])
      rk.SetValue("LOADCTRLS", flags, RegistryValueKind.DWord)
      rk.SetValue("LOADER", path, RegistryValueKind.[String])
      rk.SetValue("MANAGED", 1, RegistryValueKind.DWord)
 
      ' Create a subkey if there are any commands...
 
      If (globCmds.Count = locCmds.Count) _
        AndAlso globCmds.Count > 0 Then
        Dim ck As RegistryKey = rk.CreateSubKey("Commands")
 
        For i As Integer = 0 To globCmds.Count - 1
          ck.SetValue(globCmds(i), locCmds(i), _
            RegistryValueKind.[String])
        Next
      End If
 
      ' And the command groups, if there are any
 
      If groups.Count > 0 Then
        Dim gk As RegistryKey = rk.CreateSubKey("Groups")
 
        For Each grpName As String In groups
          gk.SetValue(grpName, grpName, _
            RegistryValueKind.[String])
        Next
      End If
 
      appk.Close()
    End Sub
 
    Private Shared Sub RemoveDemandLoadingEntries( _
      ByVal currentUser As Boolean)
 
      Try
 
        ' Choose a Registry hive based on the function input
 
        Dim hive As RegistryKey = _
          If(currentUser,Registry.CurrentUser,Registry.LocalMachine)
 
        ' Open the main AutoCAD (or vertical) and "Applications" keys
 
        Dim ack As RegistryKey = _
          hive.OpenSubKey( _
            HostApplicationServices.Current.RegistryProductRootKey)
        Dim appk As RegistryKey = _
          ack.OpenSubKey("Applications", True)
 
        ' Delete the key with the same name as this assembly
 
        appk.DeleteSubKeyTree( _
          Assembly.GetExecutingAssembly().GetName().Name)
        appk.Close()
 
      Catch
      End Try
    End Sub
  End Class
End Namespace

That’s really all there is to it. If you have any feedback regarding the behaviour of the tool, please do send us an email.

Posted at 01:47 PM in AutoCAD, AutoCAD .NET, Plugin of the Month, User interface | Permalink | Comments (6)

August 21, 2009

Allowing a user to select from multiple file formats inside AutoCAD using .NET

This is a topic that I’ve covered to some degree in a couple of previous posts:

Using AutoCAD's file selection dialog from .NET

Replacing AutoCAD's OPEN command using .NET

Neither focused on the question of allowing the user to select from a number of different file format filters (try saying “different file format filters” five times, quickly :-), so I thought I’d compare and contrast the two approaches in this post.

There are two primary mechanisms provided by AutoCAD’s .NET interface for file selection:

Methods from the Editor class:
- GetFileNameForOpen()
- GetFileNameForSave()
Classes in the Autodesk.AutoCAD.Windows namespace:
- OpenFileDialog
- SaveFileDialog

Within the two mechanisms the open and save choices are broadly similar, the main differences being around prompting the user to overwrite (in the case of save) and the need for a file to exist (in the case of open). In this case we’ll focus on open: providing the same treatment for save is left as an exercise for the reader.

Here’s the C# code that compares the two approaches. You may need to add additional project references to AcWindows.dll and System.Windows.Forms:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.Windows;
 
namespace FileSelectionOptions
{
  public class Commands
  {
    [CommandMethod("SF")]
    public void SelectFiles()
    {
      Editor ed =
        Application.DocumentManager.MdiActiveDocument.Editor;
 
      // First let's use the editor method, GetFileNameForOpen()
 
      PromptOpenFileOptions opts =
        new PromptOpenFileOptions(
          "Select a file using Editor.GetFileNameForOpen()"
        );
      opts.Filter =
        "Drawing (*.dwg)|*.dwg|Design Web Format (*.dwf)|*.dwf|" +
        "All files (*.*)|*.*";
      PromptFileNameResult pr = ed.GetFileNameForOpen(opts);
 
      if (pr.Status == PromptStatus.OK)
      {
        ed.WriteMessage(
          "\nFile selected was \"{0}\".\n",
          pr.StringResult
        );
      }
 
      // Now let's create and use an OpenFileDialog object
 
      OpenFileDialog ofd =
        new OpenFileDialog(
          "Select a file using an OpenFileDialog",
          null,
          "dwg; dwf; *",
          "SelectFileTest",
          OpenFileDialog.OpenFileDialogFlags.DoNotTransferRemoteFiles
        );
      System.Windows.Forms.DialogResult dr = ofd.ShowDialog();
      if (dr == System.Windows.Forms.DialogResult.OK)
      {
        ed.WriteMessage(
          "\nFile selected was \"{0}\".\n",
          ofd.Filename
        );
      }
    }
  }
}

Now let’s see what happens when we run the SF command.

Here’s the first dialog displayed using Editor.GetFileNameForOpen():

And here’s the equivalent dialog using OpenFileDialog:

Overall I prefer the way the control you have over the filter list using the GetFileNameForXxx() methods: OpenFileDialog has you provide the extensions and then attempts to determine the appropriate description (which works fine for DWGs but less so for other extensions, as far as I can tell).

Posted at 02:54 PM in AutoCAD, AutoCAD .NET, User interface | Permalink | Comments (0) | TrackBack (0)

August 18, 2009

Free webcast: AutoCAD .NET - Developing a User Interface

Gopinath Taget, from DevTech Americas, will be delivering a repeat session of this free webcast on Thursday, August 20. Please go to our API training schedule if you would like to register for the event (from where a recording of the previous event is also available for download (20.3 MB)).

Here’s a brief synopsis of the webcast:

This webcast will show how to integrate your application's user interface into the AutoCAD look and feel. We’ll show you how to work with .NET Forms, create your own palettes, issues surrounding .NET UI development on AutoCAD and implement Event handling so your interface can respond to actions initiated by the user. We will also talk about freely available .NET controls that the AutoCAD .NET API provides and how to use them.

Gopi tells me the content is focused on WinForms: if you are looking to integrate WPF into your UI then the information in this recent post should be of help.

Posted at 01:05 PM in AutoCAD, AutoCAD .NET, Training, User interface | Permalink | Comments (6) | TrackBack (0)

August 12, 2009

Hosting WPF content inside an AutoCAD palette

OK, OK: I know I said I’d talk more about overrules, last week, but – as is often the way, I’m afraid to say – I got distracted. The good news, though, is that I got distracted by something genuinely interesting, and well worth sharing.

I’ve been working on upgrading the WinForms user interface of an existing .NET application to use WPF, the Windows Presentation Foundation. For those wanting a thorough grounding in WPF, I recommend watching Fenton Webb’s highly-rated webcast series on WPF, just one of the interesting webcasts that can be downloaded and viewed from our API training schedule:

AutoCAD: Using WPF in your Applications - Part 1 (28.9 Mb)

AutoCAD: Using WPF in your Applications - Part 2 (16.3 Mb)

In this post I’m going to walk through creating a simple WPF User Control which we can then host inside an AutoCAD PaletteSet.

Firstly we need to add a WPF User Control to our Visual Studio 2008 (or higher) project:

We’ll accept the default name for the purposes of this project.

Now we should see our blank user-control hosted in both a designer window and a XAML editing pane:

For the content of our user-control, I decided to take a static 2D image and apply some effects to it, inspired by this page, which also has a thorough explanation of the various effects applied (which saves me from doing the same :-).

You can copy & paste this XAML into the editing pane:

<UserControl x:Class="WPF_Palette.UserControl1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Height="380" Width="300">
  <StackPanel Background="Gray">
    <Border BorderBrush="OldLace" BorderThickness="10" CornerRadius="10"
            HorizontalAlignment="Center" VerticalAlignment="Center">
      <Image Source="TTIF.png" Width="200" Height="200"
             Stretch="Fill" x:Name="blogImage" />
      <Border.RenderTransform>
        <SkewTransform CenterX="250" CenterY="0"
                       AngleX="0" AngleY="350" />
      </Border.RenderTransform>
    </Border>
    <Border Width="220" Height="300" BorderThickness="10"
            CornerRadius="10" BorderBrush="OldLace">
      <Border.Background>
        <VisualBrush Visual="{Binding ElementName=blogImage}">
          <VisualBrush.Transform>
            <ScaleTransform ScaleX="1" ScaleY="-1"
                            CenterX="200" CenterY="150" />
          </VisualBrush.Transform>
        </VisualBrush>
      </Border.Background>
      <Border.OpacityMask>
        <LinearGradientBrush StartPoint="0,0" EndPoint="0,1">
          <GradientStop Offset="0" Color="Black" />
          <GradientStop Offset="0.3" Color="Transparent" />
        </LinearGradientBrush>
      </Border.OpacityMask>
      <Border.RenderTransform>
        <SkewTransform CenterX="260" CenterY="0"
                       AngleX="40" AngleY="350" />
      </Border.RenderTransform>
    </Border>
  </StackPanel>
</UserControl>

For this to work, I added a simple screenshot of this blog as an item in the project, calling it “TTIF.png”. I simply added it to the project via the Solution Explorer, using Add –> Existing Item… no need to create a resource.

Now we should see our User Control has taken shape:

Now it’s simply a matter of defining a command to create a PaletteSet to host our WPF content:

using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.Windows;
using System.Drawing;
using System.Windows.Forms;
using System.Windows.Forms.Integration;
 
namespace WPF_Palette
{
  public class Commands
  {
    static PaletteSet _ps = null;
 
    [CommandMethod("WPFP")]
    public void ShowWPFPalette()
    {
      if (_ps == null)
      {
        // Create the palette set
 
        _ps = new PaletteSet("WPF Palette");
        _ps.Size = new Size(400, 600);
        _ps.DockEnabled =
          (DockSides)((int)DockSides.Left + (int)DockSides.Right);
 
        // Create our first user control instance and
        // host it on a palette using AddVisual()
 
        UserControl1 uc = new UserControl1();
        _ps.AddVisual("AddVisual", uc);
 
        // Create our second user control instance and
        // host it in an ElementHost, which allows
        // interop between WinForms and WPF
 
        UserControl1 uc2 = new UserControl1();
        ElementHost host = new ElementHost();
        host.AutoSize = true;
        host.Dock = DockStyle.Fill;
        host.Child = uc2;
        _ps.Add("Add ElementHost", host);
      }
 
      // Display our palette set
 
      _ps.KeepFocus = true;
      _ps.Visible = true;
    }
  }
}

For the application to build you’ll need to add project references to the .NET assemblies System.Drawing and WindowsFormsIntegration (in addition to the usual AcMgd.dll and AcDbMgd.dll, of course).

The above code deliberately adds two instances of our control into the PaletteSet, to show the different techniques for doing so:

The first uses the new (to AutoCAD 2010) AddVisual() method to add in our WPF User Control into a Palette
- This works, but doesn’t dock the control inside the palette (something I hope to see addressed in the future – as it stands this isn’t particularly useful)
The second uses an ElementHost to host our WPF User Control – essentially hosting our WPF control in one that works with a WinForms UI. We then use the standard Add() method to add it, as we have done in the past

Now the application should build. When we NETLOAD it into AutoCAD and run the WPFP command, we should see our docked palette set with the first tab visible:

We can see that this tab hosts our control, but it doesn’t fill the palette.

If we select the second tab, we see things are better, there:

If you undock the palette set you can see more easily the way the control is hosted by each palette.

I’m still on the steep part of the learning curve with respect to WPF (and expect I’ll be there for some time), but so far I’m really impressed with its capabilities, especially around binding a user-interface’s properties to the data it hosts. I’ll be sharing more of my findings related to WPF in due course.

Posted at 06:50 PM in AutoCAD, AutoCAD .NET, User interface, WPF | Permalink | Comments (9) | TrackBack (0)

July 27, 2009

Providing information on AutoCAD objects in a tooltip using .NET

One of the responses to my last post on the “Plugin of the Month” asked about showing information on an AutoCAD drawing object via a tooltip. Other than using the standard rollover tooltip properties mechanism, as shown in this previous post, the best way to achieve this is via a PointMonitor.

In the below C# code we check which object ore objects are being hovered over, get information about those objects and add them to the tooltip.

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Geometry;
 
public class PointMonitorTooltips
{
  [CommandMethod("SM")]
  public static void StartMonitor()
  {
    Editor ed =
      Application.DocumentManager.MdiActiveDocument.Editor;
    ed.PointMonitor +=
      new PointMonitorEventHandler(ed_PointMonitor);
  }
 
  [CommandMethod("XM")]
  public static void StopMonitor()
  {
    Editor ed =
      Application.DocumentManager.MdiActiveDocument.Editor;
    ed.PointMonitor -=
      new PointMonitorEventHandler(ed_PointMonitor);
  }
 
  static void ed_PointMonitor(object sender, PointMonitorEventArgs e)
  {
    Editor ed = (Editor)sender;
    Document doc = ed.Document;
 
    if (!e.Context.PointComputed)
      return;
 
    try
    {
      // Determine the size of the selection aperture
 
      short pickbox =
        (short)Application.GetSystemVariable("PICKBOX");
      Point2d extents =
        e.Context.DrawContext.Viewport.GetNumPixelsInUnitSquare(
          e.Context.ComputedPoint
        );
      double boxWidth = pickbox / extents.X;
      Vector3d vec =
        new Vector3d(boxWidth / 2, boxWidth / 2, 0.0);
 
      // Do a crossing selection using a centred box the
      // size of the aperture
 
      PromptSelectionResult pse =
        ed.SelectCrossingWindow(
          e.Context.ComputedPoint - vec,
          e.Context.ComputedPoint + vec
        );
 
      if (pse.Status != PromptStatus.OK ||
          pse.Value.Count <= 0)
        return;
 
      // Go through the results of the selection
      // and detect the curves
 
      string curveInfo = "";
 
      Transaction tr =
        doc.TransactionManager.StartTransaction();
      using (tr)
      {
        // Open each object, one by one
 
        ObjectId[] ids = pse.Value.GetObjectIds();
        foreach (ObjectId id in ids)
        {
          DBObject obj =
            tr.GetObject(id, OpenMode.ForRead);
          if (obj != null)
          {
            // If it's a curve, get its length
 
            Curve cv = obj as Curve;
            if (cv != null)
            {
              double length =
                cv.GetDistanceAtParameter(cv.EndParam);
 
              // Then add a message including the object
              // type and its length
 
              curveInfo +=
                obj.GetType().Name + "'s length: " +
                string.Format("{0:F}", length) + "\n";
            }
          }
        }
        // Cheaper than aborting
 
        tr.Commit();
      }
 
      // Add the tooltip of the lengths of the curves detected
 
      if (curveInfo != "")
        e.AppendToolTipText(curveInfo);
    }
    catch
    {
      // Not sure what we might get here, but not real action
      // needed (worth adding an Exception parameter and a
      // breakpoint, in case things need investigating).
    }
  }
}

During the command we perform a selection, using Editor.SelectCrossingWindow() specifying a window based on the selected point, using a window that’s about the size of the selection aperture (at least that’s what I’m trying to do: let me know if you’ve got a better solution for this). Having some amount of “fuzz” in the selection allows us to not have to hover very precisely over the object, which may or may not be what you’re looking for.

We then iterate through the objects, gathering information about the objects we care about. In this case we’re looking for curves: when we find one, we add its length (along with its object type) to the string we eventually add to the tooltip via AppendToolTipText().

There are two commands: SM adds the monitor, and XM removes it. Bear in mind that the event fires for all sorts of input events - including keystrokes – so you can actually cause problems unless you’re careful. As an example, I wasn’t previously checking the PointComputed status of the PointManager’s context, which is false if we’re looking at keyboard input. The code would go ahead and try to select geometry, which – for some reason unknown to me – cause the character in the keystroke buffer to be lost. Which meant that entering any command would only result in the last command being executed (via the return being processed – that one got through, OK :-). All this to point out that care should be taken when relying on events that are so integrated so deeply into AutoCAD’s user input mechanism.

So let’s see what we get after NETLOADing the module, running the SM command and hovering over a curve, in this case a line. We see a tooltip appear containing the line’s length.

And if we do the same with a lot more intersecting objects, we see that we also get the opportunity to provide information on those. It’s ultimately our choice how we manage the selection process and what we do with the results (although please don’t assume you can attempt everything from this kind of very frequently fired event: there are a number of areas where you may find things failing, especially if there’s any interactive component).

Update:

Thanks to Tony Tanzillo for keeping me honest (see his comments, below). The below code addresses a few issues with the version shown above, and should be used instead.

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Geometry;
 
public class PointMonitorTooltips
{
  [CommandMethod("SM")]
  public static void StartMonitor()
  {
    Editor ed =
      Application.DocumentManager.MdiActiveDocument.Editor;
    ed.PointMonitor +=
      new PointMonitorEventHandler(ed_PointMonitor);
  }
 
  [CommandMethod("XM")]
  public static void StopMonitor()
  {
    Editor ed =
      Application.DocumentManager.MdiActiveDocument.Editor;
    ed.TurnForcedPickOn();
    ed.PointMonitor -=
      new PointMonitorEventHandler(ed_PointMonitor);
  }
 
  static void ed_PointMonitor(object sender, PointMonitorEventArgs e)
  {
    Editor ed = (Editor)sender;
    Document doc = ed.Document;
 
    try
    {
      FullSubentityPath[] paths =
        e.Context.GetPickedEntities();
 
      // Go through the results of the selection
      // and detect the curves
 
      string curveInfo = "";
 
      Transaction tr =
        doc.TransactionManager.StartTransaction();
      using (tr)
      {
        // Open each object, one by one
 
        foreach (FullSubentityPath path in paths)
        {
          ObjectId[] ids = path.GetObjectIds();
          if (ids.Length > 0)
          {
            ObjectId id = ids[ids.GetUpperBound(0)];
 
            DBObject obj =
              tr.GetObject(id, OpenMode.ForRead);
            if (obj != null)
            {
              // If it's a curve, get its length
 
              Curve cv = obj as Curve;
              if (cv != null)
              {
                double length =
                  cv.GetDistanceAtParameter(cv.EndParam) -
                  cv.GetDistanceAtParameter(cv.StartParam);
 
                // Then add a message including the object
                // type and its length
 
                curveInfo +=
                  obj.GetType().Name + "'s length: " +
                  string.Format("{0:F}", length) + "\n";
              }
            }
          }
        }
        // Cheaper than aborting
 
        tr.Commit();
      }
 
      // Add the tooltip of the lengths of the curves detected
 
      if (curveInfo != "")
        e.AppendToolTipText(curveInfo);
    }
    catch
    {
      // Not sure what we might get here, but not real action
      // needed (worth adding an Exception parameter and a
      // breakpoint, in case things need investigating).
    }
  }
}

Posted at 04:50 PM in AutoCAD, AutoCAD .NET, Notification / Events, Selection, User interface | Permalink | Comments (8) | TrackBack (0)

July 20, 2009

Adding a dynamic password property to an AutoCAD object using .NET

In this recent post we looked at adding custom editing capabilities for dynamic properties we’ve added via .NET. In the first example we looked at a “distance” property which provided a button allowing the user to select two points. In this post we’ll look at implementing a masked string property, such as one you would use for a password.

I won’t repeat too much of the background information from the last post in this series: you should refer to that to understand the fundamentals (the fact that we’re basing this implementation on Cyrille Fauvel’s OPM .NET sample, that we’re not dealing with per-object persistence, and that we’re using “stock” ActiveX editing controls we’ve discovered via the Registry). That said, the code we’re providing here stands alone from the code in the last post, even if it’s altogether possible to combine them.

Here is the C# code to implement a simple, masked string dynamic property:

using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.Windows.OPM;
using Autodesk.AutoCAD.Windows.ToolPalette;
using System;
using System.Reflection;
using System.Runtime.InteropServices;
 
namespace OPMNetSample
{
  #region Our Custom Password Property
  [
    Guid("B5D9010E-48A2-4bfb-8601-76A7B1007C68"),
    ProgId("OPMNetSample.PasswordProperty.1"),
    ClassInterface(ClassInterfaceType.None),
    ComDefaultInterface(typeof(IDynamicProperty2)),
    ComVisible(true)
  ]
  public class PasswordProp : IDynamicProperty2, IAcPiPropertyDisplay
  {
    private IDynamicPropertyNotify2 _pSink = null;
    private string _password = "";
 
    #region IDynamicProperty2 methods
 
    // Unique property ID
 
    public void GetGUID(out Guid propGUID)
    {
      propGUID =
        new Guid("B5D9010E-48A2-4bfb-8601-76A7B1007C68");
    }
 
    // Property display name
 
    public void GetDisplayName(out string szName)
    {
      szName = "Password";
    }
 
    // Show/Hide property in the OPM, for this object instance
 
    public void IsPropertyEnabled(object pUnk, out int bEnabled)
    {
      bEnabled = 1;
    }
 
    // Is property showing but disabled
 
    public void IsPropertyReadOnly(out int bReadonly)
    {
      bReadonly = 0;
    }
 
    // Get the property description string
 
    public void GetDescription(out string szName)
    {
      szName =
        "This masked property is a string";
    }
 
    // OPM will typically display these in an edit field
    // optional: meta data representing property type name,
    // ex. ACAD_ANGLE
 
    public void GetCurrentValueName(out string szName)
    {
      throw new System.NotImplementedException();
    }
 
    // What is the property type, ex. VT_R8
 
    public void GetCurrentValueType(out ushort varType)
    {
      // The Property Inspector supports the following data
      // types for dynamic properties:
      // VT_I2 (2), VT_I4 (3), VT_R4 (4), VT_R8 (5),
      // VT_BSTR (8), VT_BOOL (11), and VT_USERDEFINED (29). 
 
      varType = 8; // VT_BSTR
    }
 
    // Get the property value, passes the specific object
    // we need the property value for.
 
    public void GetCurrentValueData(object pUnk, ref object pVarData)
    {
      pVarData = _password;
    }
 
    // Set the property value, passes the specific object we
    // want to set the property value for
 
    public void SetCurrentValueData(object pUnk, object varData)
    {
      _password = varData.ToString();
      System.Windows.Forms.MessageBox.Show(
        "String entered was \"" + _password + "\"."
      );
    }
 
    // OPM passes its implementation of IDynamicPropertyNotify, you
    // cache it and call it to inform OPM your property has changed
 
    public void Connect(object pSink)
    {
      _pSink = (IDynamicPropertyNotify2)pSink;
    }
 
    public void Disconnect() {
      _pSink = null;
    }
 
    #endregion
 
    #region IAcPiPropertyDisplay methods
 
    public void GetCustomPropertyCtrl(
      object id, uint lcid, out string progId
    )
    {
      progId = "AcPEXCtl.AcPePropertyEditorPwdText.16";
    }
 
    public void GetPropertyWeight(object id, out int propertyWeight)
    {
      propertyWeight = 0;
    }
 
    public void GetPropertyIcon(object id, out object icon)
    {
      icon = null;
    }
 
    public void GetPropTextColor(object id, out uint textColor)
    {
      textColor = 0;
    }
 
    public void IsFullView(
      object id, out bool visible, out uint integralHeight
    )
    {
      visible = false;
      integralHeight = 1;
    }
    #endregion
  }
  #endregion
 
  #region Application Entry Point
  public class MyEntryPoint : IExtensionApplication
  {
    protected internal PasswordProp passProp = null;
 
    public void Initialize()
    {
      Assembly.LoadFrom("asdkOPMNetExt.dll");
 
      // Add the Dynamic Property
 
      Dictionary classDict = SystemObjects.ClassDictionary;
      RXClass lineDesc = (RXClass)classDict.At("AcDbLine");
      IPropertyManager2 pPropMan =
        (IPropertyManager2)xOPM.xGET_OPMPROPERTY_MANAGER(lineDesc);
 
      passProp = new PasswordProp();
      pPropMan.AddProperty((object)passProp);
    }
 
    public void Terminate()
    {
      // Remove the Dynamic Property
 
      Dictionary classDict = SystemObjects.ClassDictionary;
      RXClass lineDesc = (RXClass)classDict.At("AcDbLine");
      IPropertyManager2 pPropMan =
        (IPropertyManager2)xOPM.xGET_OPMPROPERTY_MANAGER(lineDesc);
 
      pPropMan.RemoveProperty((object)passProp);
      passProp = null;
    }
  }
  #endregion
}

Let’s see what happens when we NETLOAD the asdkOPMNetExt.dll and our OPMNetSample.dll, and then select a standard line:

Once we start entering a string inside our dynamic password property, we see it displayed as a masked string:

And once we finish entering our string, we can see that our code has the unmasked data available to it – here’s a MessageBox we throw up to display the contents:

If we really wanted to store this securely – to avoid any determined application from snooping the underlying data – then we would really need to encrypt it before assigning it to our object (whether in Xdata or an Xrecord stored in the extension dictionary of an object). Beyond that we might even want to take measures to make sure the variable – as stored in memory, not just persisted with the object – isn’t readable by external applications. But again, this is beyond the scope of this post, which is really just to introduce another property editing control available inside AutoCAD.

Posted at 10:51 AM in AutoCAD, AutoCAD .NET, Object properties, User interface | Permalink | Comments (6) | TrackBack (0)

July 15, 2009

Adding a dynamic distance property to an AutoCAD object using .NET

Back in these previous posts, we introduced an ObjectARX module that exposed AutoCAD’s Property Palette to .NET (thanks again to Cyrille Fauvel for his work on this :-). In this post we’re going to build on this work to demonstrate how to integrate properties with more advanced editing controls into the Property Palette.

[Note: this sample does not deal with persisting the data with an object. If you want to store your data with a particular object, I suggest taking a look at this previous post which demonstrates how to use Xdata to do so.]

This code is being built on top of the sample project provided with the OPM .NET implementation, which I’ve posted previously for AutoCAD 2007-2009 and for AutoCAD 2010. It defines a custom dynamic property – much like the original CustomProp, an integer property – but this one implements a new interface, IAcPiPropertyDisplay. This special interface allows you to – among other things – specify a custom editing control, which gets instantiated by the Property Palette and is then used to allow editing of the property.

The ObjectARX documentation contains this information on the main method we’re interested in implementing, GetCustomPropertyCtrl():

Supplies a custom ActiveX control for property display/edit on a per-property basis.

Before attempting to pick one of the ACPEX stock custom ActiveX controls for property display/edit, the Property Inspector calls this method to see if the object/command wishes to supply its own custom ActiveX control. This method is called on a per-property basis (both static and dynamic) for an object/command whose properties are active for display in the Property Inspector.

The supplied custom control must implement IPropertyEditCtrl to be displayed for property value display/edit. The Property Inspector releases the output BSTR pointer after its use.

We want to enable this interface for use from .NET. In the previous cases we’ve had to do some extra work to expose or enable our Property Palette interfaces for use from .NET, but luckily this work has already been done for AutoCAD’s Tool Palette implementation. We can now simply add an assembly reference to AcTcMgd.dll and include the Autodesk.AutoCAD.Windows.ToolPalette namespace in our code.

[Note: I found this assembly in the inc-win32 folder of the ObjectARX SDK for AutoCAD 2010 (I’m running AutoCAD 2010 on Vista 32-bit), and it’s not clear to me when exactly we delivered this implementation - whether it was done for AutoCAD 2010 or beforehand. If AcTcMgd.dll is not available for your version of AutoCAD, it is still an option to expose this interface for use from .NET yourself, following the examples shown when we originally introduced the OPM .NET implementation.]

When we implement our GetCustomPropertyCtrl() method, we then need to set the string output argument to the ProgId of the editing control we wish to use. To decide an appropriate ProgId, I looked into the Registry, to identify the candidates:

It’s also possible to implement your own truly custom editing control exposing the IPropertyEditCtrl interface, but that’s way beyond the scope of this post. :-)

For our custom distance property, we’re going to use a (standard) custom control that allows the user to select two points in the drawing; the distance between them then gets set as our dynamic property’s value. The ProgId for this control is “AcPEXCtl.AcPePick2PointsCtrl.16”.

Otherwise the methods of IAcPiPropertyDisplay should be fairly straightforward to understand, although perhaps IsFullView() requires a little explanation: the “visible” parameter actually indicates whether the control should take up the whole of the row – obscuring the property name – which is why we set it to false.

One final note: I’ve remapped the GUID for the property, to prevent it from conflicting with the previous CustomProp implementation.

Here’s the C# code for our custom distance property:

using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.Windows.OPM;
using Autodesk.AutoCAD.Windows.ToolPalette;
using System;
using System.Reflection;
using System.Runtime.InteropServices;
 
namespace OPMNetSample
{
  #region Our Custom Distance Property
  [
    Guid("78286EBD-7380-4bb5-9EA6-1742677FA2E3"),
    ProgId("OPMNetSample.DistanceProperty.1"),
    ClassInterface(ClassInterfaceType.None),
    ComDefaultInterface(typeof(IDynamicProperty2)),
    ComVisible(true)
  ]
  public class DistanceProp : IDynamicProperty2, IAcPiPropertyDisplay
  {
    private IDynamicPropertyNotify2 _pSink = null;
    private double _value = 0.0;
 
    #region IDynamicProperty2 methods
 
    // Unique property ID
 
    public void GetGUID(out Guid propGUID)
    {
      propGUID =
        new Guid("78286EBD-7380-4bb5-9EA6-1742677FA2E3");
    }
 
    // Property display name
 
    public void GetDisplayName(out string szName)
    {
      szName = "Distance";
    }
 
    // Show/Hide property in the OPM, for this object instance
 
    public void IsPropertyEnabled(object pUnk, out int bEnabled)
    {
      bEnabled = 1;
    }
 
    // Is property showing but disabled
 
    public void IsPropertyReadOnly(out int bReadonly)
    {
      bReadonly = 0;
    }
 
    // Get the property description string
 
    public void GetDescription(out string szName)
    {
      szName =
        "This distance property is from picking two points";
    }
 
    // OPM will typically display these in an edit field
    // optional: meta data representing property type name,
    // ex. ACAD_ANGLE
 
    public void GetCurrentValueName(out string szName)
    {
      throw new System.NotImplementedException();
    }
 
    // What is the property type, ex. VT_R8
 
    public void GetCurrentValueType(out ushort varType)
    {
      // The Property Inspector supports the following data
      // types for dynamic properties:
      // VT_I2 (2), VT_I4 (3), VT_R4 (4), VT_R8 (5),
      // VT_BSTR (8), VT_BOOL (11), and VT_USERDEFINED (29). 
 
      varType = 4; // VT_R4
    }
 
    // Get the property value, passes the specific object
    // we need the property value for.
 
    public void GetCurrentValueData(object pUnk, ref object pVarData)
    {
      pVarData = _value;
    }
 
    // Set the property value, passes the specific object we
    // want to set the property value for
 
    public void SetCurrentValueData(object pUnk, object varData)
    {
      _value = (double)varData;
    }
 
    // OPM passes its implementation of IDynamicPropertyNotify, you
    // cache it and call it to inform OPM your property has changed
 
    public void Connect(object pSink)
    {
      _pSink = (IDynamicPropertyNotify2)pSink;
    }
 
    public void Disconnect() {
      _pSink = null;
    }
 
    #endregion
 
    #region IAcPiPropertyDisplay methods
 
    public void GetCustomPropertyCtrl(
      object id, uint lcid, out string progId
    )
    {
      progId = "AcPEXCtl.AcPePick2PointsCtrl.16";
    }
 
    public void GetPropertyWeight(object id, out int propertyWeight)
    {
      propertyWeight = 0;
    }
 
    public void GetPropertyIcon(object id, out object icon)
    {
      icon = null;
    }
 
    public void GetPropTextColor(object id, out uint textColor)
    {
      textColor = 0;
    }
 
    public void IsFullView(
      object id, out bool visible, out uint integralHeight
    )
    {
      visible = false;
      integralHeight = 1;
    }
    #endregion
  }
  #endregion
 
  #region Application Entry Point
  public class MyEntryPoint : IExtensionApplication
  {
    protected internal DistanceProp distProp = null;
 
    public void Initialize()
    {
      Assembly.LoadFrom("asdkOPMNetExt.dll");
 
      // Add the Dynamic Property
 
      Dictionary classDict = SystemObjects.ClassDictionary;
      RXClass lineDesc = (RXClass)classDict.At("AcDbLine");
      IPropertyManager2 pPropMan =
        (IPropertyManager2)xOPM.xGET_OPMPROPERTY_MANAGER(lineDesc);
 
      distProp = new DistanceProp();
      pPropMan.AddProperty((object)distProp);
    }
 
    public void Terminate()
    {
      // Remove the Dynamic Property
 
      Dictionary classDict = SystemObjects.ClassDictionary;
      RXClass lineDesc = (RXClass)classDict.At("AcDbLine");
      IPropertyManager2 pPropMan =
        (IPropertyManager2)xOPM.xGET_OPMPROPERTY_MANAGER(lineDesc);
 
      pPropMan.RemoveProperty((object)distProp);
      distProp = null;
    }
  }
  #endregion
}

Here’s what we see when we NETLOAD the asdkOPMNetExt.dll and our OPMNetSample.dll, and then select a standard line:

When we select the property we see we get a custom editing icon:

When we click that button, we get prompted to select two points in the drawing:

Pick a start point in the drawing:
Pick an end point in the drawing:

Once we’ve done so, the distance between the two points gets assigned to our property:

Bear in mind that we’re currently storing this value with the property, not with the line itself. So you’ll see the same value irrespective of the line you’ve selected. See the note at the beginning of this post if you wish to go further and attach this data per object.

I’m going to spend some time looking further into the capabilities of the custom control mechanism: in the next post in this series we’ll look at hosting a masked string (as in a password) dynamic property inside the Property Palette. If you have suggestions for additional controls to implement, please let me know (and I’ll see what I can figure out :-).

Posted at 11:33 AM in AutoCAD, AutoCAD .NET, Object properties, User interface | Permalink | Comments (19) | TrackBack (0)

July 09, 2009

Reminder: free API webcast series on using WPF in your AutoCAD applications

As mentioned in this previous post, Fenton Webb is presenting a two-part series on using the Windows Presentation Foundation (WPF) in your AutoCAD .NET applications. The first session on June 2nd was recorded and the second is to be held next week on July 14th.

You can register for upcoming webcasts - and access recordings for previous webcasts – via our API training schedule (which can also be accessed via this easy-to-remember URL: http://www.autodesk.com/apitraining).

Posted at 12:59 PM in AutoCAD, AutoCAD .NET, Training, User interface | Permalink | Comments (0) | TrackBack (0)

Through the Interface

Kean Walmsley

December 2009

Post Index

Reverse Index

Twitter Updates

Autodesk Blogs