Through the Interface

Updated version of Screenshot now available

We’ve had a few reports of issues with the Screenshot “Plugin of the Month”. They fall into two main categories:

Attempting to NETLOAD the application DLL from a network share

Within the ReadMe for each of the plugins we’ve documented that each application’s DLL module should be copied to the local file system – preferably inside the AutoCAD Program Files folder – before being loaded by NETLOAD. We recommend this because it essentially stops users from hitting a whole category of .NET Framework-related problems when loading and running the plugins.

If you didn’t heed this advice then you’d probably find that, as soon as the SCREENSHOT command was launched, you received a message such as “FATAL ERROR: Unsupported version of Windows Presentation Foundation.”

Now I don’t have an exhaustive list of reasons it’s best to place .NET DLLs in the AutoCAD root program folder, but my understanding/belief is that it’s down to two main ones:

1. Security

The .NET Framework implements security for different zones, and – up until the .NET Framework 3.5 SP1 – the default security setting for the “Local Intranet” (which affects applications being loaded from network shares) was “Medium Trust”. This level of trust means:

Programs might not be able to access most protected resources such as the registry or security policy settings, or access your local file system without user interaction. Programs will not be able to connect back to their site of origin, resolve domain names, and use all windowing resources.

Our “Plugin of the Month” applications target lower versions of the .NET Framework (we want to avoid forcing people to use the latest version of the framework and want the applications to run – where possible – at least as far back as AutoCAD 2007), and so their default level of trust will make running from a network share a problem.

Now it’s possible to use the Control Panel to configure earlier versions of the .NET Framework to be more tolerant of network-resident DLLs (you can change the trust level for the local intranet zone to be higher), but it’s still not something I’d recommend: I’m pretty sure this is only one aspect of the situation, and it would be dangerous to assume it’s all that’s needed.

2. Assembly Loading

The other main reason for putting modules in AutoCAD’s root program folder is related to the loading of .NET assemblies into AutoCAD’s AppDomain (which is basically what the NETLOAD command does, and this choice of architecture is why there’s no NETUNLOAD command).

While NETLOAD uses Assembly.LoadFrom() to load in .NET assembly DLLs – which does allow you to specify a path other than the current folder – there does appear to be some fragility overall with the location of assemblies and how they reference each other. It’s safest to place assemblies at a location beneath the calling executable (i.e. AutoCAD).

Capturing images with the “force foreground to black” option results in a completely black image

This one is definitely down to me. A big thank you to Harry Kortekaas for very diligently helping me identify the problem.

It actually came down to some poor application logic on my side: I was forgetting to check the “use white background” flag at the right place, and had also inverted the test for being in modelspace vs. paperspace. By chance – in many situations – the white background was picked up correctly from the paperspace, and so the issue wasn’t easily reproducible.

Anyway, a fix has now been integrated into version 1.0.2 of the application, which is now downloadable via Autodesk Labs. I’ve also included an updated version of the code below.

 

A third type of issue has been reported, but I haven’t yet been able to determine the cause: on one system (meaning: one reported, so far) the file selection dialog and the dynamic input graphics are not being refreshed away in time for the capture to take place.

This is similar to something we’ve been aware of from early on - the fact that the call to Editor.GetFileNameForSave() returns control to the application before the Operating System has had the chance to refresh the screen – so I built a delay (a call to System.Threading.Thread.Sleep()) into the original application to wait for a second (we started at 0.1s and worked our way upwards) which seemed to address it for all the systems upon which the application was tested.

At first it seemed – during the diagnosis of this particular issue – that this delay needed increasing, and so I added it to the per-user application settings (with the default value of 1.0, i.e. a second). This is now configurable via a new command – CONFIGSS – the logic being to keep rarely-used configuration options apart from the common ones accessible via the SCREENSHOT command. In this particular situation, though, no amount of delay seemed to help.

The same person reported an issue with the input box and temporary dimensions displayed during dynamic input not being repainted away on this particular system when the image is placed on the clipboard, so I’ve also introduced a configurable delay there, too. This is also set using CONFIGSS – the default is currently 0 seconds, to replicate the previous behaviour.

I suspect that both issues are actually down to a configuration problem (we’ll hopefully see whether my suspicion is valid), but I’ve left the capability to configure them in the application, in any case. People may also choose to reduce the current delay using CONFIGSS, as one second was on the high end: 0.3 seconds should be enough for the majority of systems. Just think of all the time you can get back!   :-)

If anyone else out there has seen something similar to this with the Screenshot application, please do let us know.

The CONFIGSS command has a third setting exposed (although it’s the first one it prompts for), and this was also introduced after receiving feedback from the same source: it’s sometimes preferred to have a boundary zone or buffer around the extents chosen via the “Objects” option, so that the selection isn’t so tight-fitting around the objects. The application now has a default of 10% of the screen extents’ width or height (whichever is larger) that will get added automatically. To go back to the old behaviour you can configure this percentage to zero using CONFIGSS.

Here’s the updated C# code: the compiled version of which (again, version 1.0.2) is now available:

// (C) Copyright 2009 by Autodesk, Inc.

//

// Permission to use, copy, modify, and distribute this software in

// object code form for any purpose and without fee is hereby granted,

// provided that the above copyright notice appears in all copies and

// that both that copyright notice and the limited warranty and

// restricted rights notice below appear in all supporting

// documentation.

//

// AUTODESK PROVIDES THIS PROGRAM "AS IS" AND WITH ALL FAULTS.

// AUTODESK SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTY OF

// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE.  AUTODESK, INC.

// DOES NOT WARRANT THAT THE OPERATION OF THE PROGRAM WILL BE

// UNINTERRUPTED OR ERROR FREE.

//

// Use, duplication, or disclosure by the U.S. Government is subject to

// restrictions set forth in FAR 52.227-19 (Commercial Computer

// Software - Restricted Rights) and DFAR 252.227-7013(c)(1)(ii)

// (Rights in Technical Data and Computer Software), as applicable.

//

 

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.GraphicsInterface;

using Autodesk.AutoCAD.GraphicsSystem;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Colors;

 

using System.Drawing.Imaging;

using System.Drawing.Printing;

using System.Drawing.Drawing2D;

using System.Drawing;

using System.Runtime.InteropServices;

using System.Collections;

using System.Configuration;

using System;

 

using DemandLoading;

 

namespace Screenshot

{

  public class ScreenshotApplication : IExtensionApplication

  {

    // Define a class for our custom data

 

    public class AppData : ApplicationSettingsBase

    {

      [UserScopedSetting()]

      [DefaultSettingValue("true")]

      public bool Clipboard

      {

        get { return ((bool)this["Clipboard"]); }

        set { this["Clipboard"] = (bool)value; }

      }

      [UserScopedSetting()]

      [DefaultSettingValue("false")]

      public bool Print

      {

        get { return ((bool)this["Print"]); }

        set { this["Print"] = (bool)value; }

      }

      [UserScopedSetting()]

      [DefaultSettingValue("false")]

      public bool WhiteBackground

      {

        get { return ((bool)this["WhiteBackground"]); }

        set { this["WhiteBackground"] = (bool)value; }

      }

      [UserScopedSetting()]

      [DefaultSettingValue("false")]

      public bool BlackForeground

      {

        get { return ((bool)this["BlackForeground"]); }

        set { this["BlackForeground"] = (bool)value; }

      }

      [UserScopedSetting()]

      [DefaultSettingValue("false")]

      public bool Grayscale

      {

        get { return ((bool)this["Grayscale"]); }

        set { this["Grayscale"] = (bool)value; }

      }

      [UserScopedSetting()]

      [DefaultSettingValue("0.1")]

      public double ExtentsScale

      {

        get { return ((double)this["ExtentsScale"]); }

        set { this["ExtentsScale"] = (double)value; }

      }

      [UserScopedSetting()]

      [DefaultSettingValue("1.0")]

      public double FileCaptureDelay

      {

        get { return ((double)this["FileCaptureDelay"]); }

        set { this["FileCaptureDelay"] = (double)value; }

      }

      [UserScopedSetting()]

      [DefaultSettingValue("0.0")]

      public double ClipboardCaptureDelay

      {

        get { return ((double)this["ClipboardCaptureDelay"]); }

        set { this["ClipboardCaptureDelay"] = (double)value; }

      }

    }

 

    // A struct for communicating colours to/from AutoCAD

 

    public struct AcColorSettings

    {

      public UInt32 dwGfxModelBkColor;

      public UInt32 dwGfxLayoutBkColor;

      public UInt32 dwParallelBkColor;

      public UInt32 dwBEditBkColor;

      public UInt32 dwCmdLineBkColor;

      public UInt32 dwPlotPrevBkColor;

      public UInt32 dwSkyGradientZenithColor;

      public UInt32 dwSkyGradientHorizonColor;

      public UInt32 dwGroundGradientOriginColor;

      public UInt32 dwGroundGradientHorizonColor;

      public UInt32 dwEarthGradientAzimuthColor;

      public UInt32 dwEarthGradientHorizonColor;

      public UInt32 dwModelCrossHairColor;

      public UInt32 dwLayoutCrossHairColor;

      public UInt32 dwParallelCrossHairColor;

      public UInt32 dwPerspectiveCrossHairColor;

      public UInt32 dwBEditCrossHairColor;

      public UInt32 dwParallelGridMajorLines;

      public UInt32 dwPerspectiveGridMajorLines;

      public UInt32 dwParallelGridMinorLines;

      public UInt32 dwPerspectiveGridMinorLines;

      public UInt32 dwParallelGridAxisLines;

      public UInt32 dwPerspectiveGridAxisLines;

      public UInt32 dwTextForeColor;

      public UInt32 dwTextBkColor;

      public UInt32 dwCmdLineForeColor;

      public UInt32 dwAutoTrackingVecColor;

      public UInt32 dwLayoutATrackVecColor;

      public UInt32 dwParallelATrackVecColor;

      public UInt32 dwPerspectiveATrackVecColor;

      public UInt32 dwBEditATrackVecColor;

      public UInt32 dwModelASnapMarkerColor;

      public UInt32 dwLayoutASnapMarkerColor;

      public UInt32 dwParallelASnapMarkerColor;

      public UInt32 dwPerspectiveASnapMarkerColor;

      public UInt32 dwBEditASnapMarkerColor;

      public UInt32 dwModelDftingTooltipColor;

      public UInt32 dwLayoutDftingTooltipColor;

      public UInt32 dwParallelDftingTooltipColor;

      public UInt32 dwPerspectiveDftingTooltipColor;

      public UInt32 dwBEditDftingTooltipColor;

      public UInt32 dwModelDftingTooltipBkColor;

      public UInt32 dwLayoutDftingTooltipBkColor;

      public UInt32 dwParallelDftingTooltipBkColor;

      public UInt32 dwPerspectiveDftingTooltipBkColor;

      public UInt32 dwBEditDftingTooltipBkColor;

      public UInt32 dwModelLightGlyphs;

      public UInt32 dwLayoutLightGlyphs;

      public UInt32 dwParallelLightGlyphs;

      public UInt32 dwPerspectiveLightGlyphs;

      public UInt32 dwBEditLightGlyphs;

      public UInt32 dwModelLightHotspot;

      public UInt32 dwLayoutLightHotspot;

      public UInt32 dwParallelLightHotspot;

      public UInt32 dwPerspectiveLightHotspot;

      public UInt32 dwBEditLightHotspot;

      public UInt32 dwModelLightFalloff;

      public UInt32 dwLayoutLightFalloff;

      public UInt32 dwParallelLightFalloff;

      public UInt32 dwPerspectiveLightFalloff;

      public UInt32 dwBEditLightFalloff;

      public UInt32 dwModelLightStartLimit;

      public UInt32 dwLayoutLightStartLimit;

      public UInt32 dwParallelLightStartLimit;

      public UInt32 dwPerspectiveLightStartLimit;

      public UInt32 dwBEditLightStartLimit;

      public UInt32 dwModelLightEndLimit;

      public UInt32 dwLayoutLightEndLimit;

      public UInt32 dwParallelLightEndLimit;

      public UInt32 dwPerspectiveLightEndLimit;

      public UInt32 dwBEditLightEndLimit;

      public UInt32 dwModelCameraGlyphs;

      public UInt32 dwLayoutCameraGlyphs;

      public UInt32 dwParallelCameraGlyphs;

      public UInt32 dwPerspectiveCameraGlyphs;

      public UInt32 dwModelCameraFrustrum;

      public UInt32 dwLayoutCameraFrustrum;

      public UInt32 dwParallelCameraFrustrum;

      public UInt32 dwPerspectiveCameraFrustrum;

      public UInt32 dwModelCameraClipping;

      public UInt32 dwLayoutCameraClipping;

      public UInt32 dwParallelCameraClipping;

      public UInt32 dwPerspectiveCameraClipping;

      public int nModelCrosshairUseTintXYZ;

      public int nLayoutCrosshairUseTintXYZ;

      public int nParallelCrosshairUseTintXYZ;

      public int nPerspectiveCrosshairUseTintXYZ;

      public int nBEditCrossHairUseTintXYZ;

      public int nModelATrackVecUseTintXYZ;

      public int nLayoutATrackVecUseTintXYZ;

      public int nParallelATrackVecUseTintXYZ;

      public int nPerspectiveATrackVecUseTintXYZ;

      public int nBEditATrackVecUseTintXYZ;

      public int nModelDftingTooltipBkUseTintXYZ;

      public int nLayoutDftingTooltipBkUseTintXYZ;

      public int nParallelDftingTooltipBkUseTintXYZ;

      public int nPerspectiveDftingTooltipBkUseTintXYZ;

      public int nBEditDftingTooltipBkUseTintXYZ;

      public int nParallelGridMajorLineTintXYZ;

      public int nPerspectiveGridMajorLineTintXYZ;

      public int nParallelGridMinorLineTintXYZ;

      public int nPerspectiveGridMinorLineTintXYZ;

      public int nParallelGridAxisLineTintXYZ;

      public int nPerspectiveGridAxisLineTintXYZ;

    };

 

    // For the coordinate tranformation we need... 

 

    // A Win32 function:

 

    [DllImport("user32.dll")]

    static extern bool ClientToScreen(IntPtr hWnd, ref Point pt);

 

    // And to access the colours in AutoCAD, we need ObjectARX...

 

    [DllImport("acad.exe",

    CallingConvention = CallingConvention.Cdecl,

    EntryPoint = "?acedGetCurrentColors@@YAHPAUAcColorSettings@@@Z"

    )]

    static extern bool acedGetCurrentColors32(

      out AcColorSettings colorSettings

    );

 

    [DllImport("acad.exe",

    CallingConvention = CallingConvention.Cdecl,

    EntryPoint = "?acedSetCurrentColors@@YAHPAUAcColorSettings@@@Z"

    )]

    static extern bool acedSetCurrentColors32(

      ref AcColorSettings colorSettings

    );

 

    // 64-bit versions of these functions...

 

    [DllImport("acad.exe",

    CallingConvention = CallingConvention.Cdecl,

    EntryPoint = "?acedGetCurrentColors@@YAHPEAUAcColorSettings@@@Z"

    )]

    static extern bool acedGetCurrentColors64(

      out AcColorSettings colorSettings

    );

 

    [DllImport("acad.exe",

    CallingConvention = CallingConvention.Cdecl,

    EntryPoint = "?acedSetCurrentColors@@YAHPEAUAcColorSettings@@@Z"

    )]

    static extern bool acedSetCurrentColors64(

      ref AcColorSettings colorSettings

    );

 

    // Helper functions that call automatically to 32- or 64-bit

    // versions, as appropriate

 

    static bool acedGetCurrentColors(

      out AcColorSettings colorSettings

    )

    {

      if (IntPtr.Size > 4)

        return acedGetCurrentColors64(out colorSettings);

      else

        return acedGetCurrentColors32(out colorSettings);

    }

 

    static bool acedSetCurrentColors(

      ref AcColorSettings colorSettings

    )

    {

      if (IntPtr.Size > 4)

        return acedSetCurrentColors64(ref colorSettings);

      else

        return acedSetCurrentColors32(ref colorSettings);

    }

 

    // IExtensionApplication protocol

 

    public void Initialize()

    {

      try

      {

        RegistryUpdate.RegisterForDemandLoading();

      }

      catch

      { }

    }

 

    public void Terminate()

    {

    }

 

    [CommandMethod("ADNPLUGINS", "REMOVESS", CommandFlags.Modal)]

    static public void RemoveScreenshot()

    {

      RegistryUpdate.UnregisterForDemandLoading();

    }

 

    [CommandMethod("ADNPLUGINS", "CONFIGSS", CommandFlags.Modal)]

    static public void ConfigureScreenshot()

    {

      // An additional command for some "advanced" configuration

      // options

 

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

 

      // Retrieve our application settings (or create new ones)

 

      AppData ad = new AppData();

      ad.Reload();

 

      if (ad != null)

      {

        // Ask the user for the percentage increase to apply to

        // the extents determined by the Objects option

 

        PromptIntegerOptions pio =

          new PromptIntegerOptions(

            "\nPercentage increase when capturing " +

            "object extents: "

          );

        pio.DefaultValue = (int)(ad.ExtentsScale * 100);

        pio.LowerLimit = 0;

        pio.UpperLimit = 100;

        pio.UseDefaultValue = true;

 

        PromptIntegerResult pir = ed.GetInteger(pio);

        if (pir.Status != PromptStatus.OK)

          return;

 

        ad.ExtentsScale = pir.Value * 0.01;

 

        // Ask the use for the delay to apply after a file

        // has been selected, to allow the OS to redraw their

        // screen graphics

 

        PromptDoubleOptions pdo =

          new PromptDoubleOptions(

            "\nDelay in seconds to allow " +

            "repaint after file selection: "

          );

        pdo.DefaultValue = ad.FileCaptureDelay;

        pdo.AllowNegative = false;

        pdo.UseDefaultValue = true;

 

        PromptDoubleResult pdr = ed.GetDouble(pdo);

        if (pdr.Status != PromptStatus.OK)

          return;

 

        ad.FileCaptureDelay = pdr.Value;

 

        // Ask the user for the delay to apply before a

        // clipboard capture to allow any dynamic

        // input graphics to be undrawn

 

        pdo.Message =

          "\nDelay in seconds to allow " +

          "repaint before clipboard selection: ";

        pdo.DefaultValue = ad.ClipboardCaptureDelay;

 

        pdr = ed.GetDouble(pdo);

        if (pdr.Status != PromptStatus.OK)

          return;

 

        ad.ClipboardCaptureDelay = pdr.Value;

 

        ad.Save();

      }

    }

 

    // Command to capture the main and active drawing windows

    // or a user-selected portion of a drawing

 

    [CommandMethod("ADNPLUGINS", "SCREENSHOT", CommandFlags.Modal)]

    static public void CaptureScreenShot()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

 

      // Retrieve our application settings (or create new ones)

 

      AppData ad = new AppData();

      ad.Reload();

 

      if (ad != null)

      {

        string filename = "";

        bool settingschosen;

        PromptPointResult ppr;

 

        do

        {

          settingschosen = false;

 

          // Ask the user for the screen window to capture

 

          PrintSettings(ed, ad);

          PromptPointOptions ppo =

            new PromptPointOptions(

              "\nSelect first point of capture window or " +

              "[Document/Application/Objects/Settings]: ",

              "Document Application Objects Settings"

            );

 

          // Get the first point of the capture window,

          // or a keyword

 

          ppr = ed.GetPoint(ppo);

 

          if (ppr.Status == PromptStatus.Keyword)

          {

            if (ppr.StringResult == "Document")

            {

              // Capture the active document window

 

              filename = PauseOrFilename(ed, ad);

 

              ScreenShotToFile(

                Application.DocumentManager.

                  MdiActiveDocument.Window,

                30, 26, 10, 10,

                filename,

                ad

              );

            }

            else if (ppr.StringResult == "Application")

            {

              // Capture the entire application window

 

              filename = PauseOrFilename(ed, ad);

 

              ScreenShotToFile(

                Application.MainWindow,

                0, 0, 0, 0,

                filename,

                ad

              );

            }

            else if (ppr.StringResult == "Objects")

            {

              // Ask the user to select a number of entities

 

              PromptSelectionResult psr =

                ed.GetSelection();

 

              if (psr.Status == PromptStatus.OK)

              {

                // Regenerate to clear any selection highlighting

 

                ed.WriteMessage("\n");

                ed.Regen();

 

                // Generate screen coordinate points based on the

                // drawing points selected

 

                // First we get the viewport number

 

                short vp =

                  (short)Application.GetSystemVariable("CVPORT");

 

                // Then the handle to the current drawing window

 

                IntPtr hWnd = doc.Window.Handle;

 

                // Get the screen extents of the selected entities

 

                Point pt1, pt2;

                GetExtentsOfSelection(

                  ed, doc, hWnd, vp, psr.Value, out pt1, out pt2

                );

 

                ApplyScaleToExtents(ad.ExtentsScale,ref pt1,ref pt2);

 

                // Now save this portion of our screen as a raster

                // image

 

                filename = PauseOrFilename(ed, ad);

 

                ScreenShotToFile(pt1, pt2, filename, ad);

              }

            }

            else if (ppr.StringResult == "Settings")

            {

              if (GetSettings(ed, ad))

                ad.Save();

              settingschosen = true;

            }

          }

        }

        while (settingschosen); // Loop if settings were modified

 

        if (ppr.Status == PromptStatus.OK)

        {

          // Now we're ready to select the second point

 

          Point3d first = ppr.Value;

 

          ppr =

            ed.GetCorner(

              "\nSelect second point of capture window: ",

              first

            );

          if (ppr.Status != PromptStatus.OK)

            return;

 

          Point3d second = ppr.Value;

 

          // Generate screen coordinate points based on the

          // drawing points selected

 

          Point pt1, pt2;

 

          // First we get the viewport number

 

          short vp =

            (short)Application.GetSystemVariable("CVPORT");

 

          // Then the handle to the current drawing window

 

          IntPtr hWnd = doc.Window.Handle;

 

          // Now calculate the selected corners in screen coordinates

 

          pt1 = ScreenFromDrawingPoint(ed, hWnd, first, vp, true);

          pt2 = ScreenFromDrawingPoint(ed, hWnd, second, vp, true);

 

          // Now save this portion of our screen as a raster image

 

          filename = PauseOrFilename(ed, ad);

 

          ScreenShotToFile(pt1, pt2, filename, ad);

        }

      }

    }

 

    // If using the clipboard let's introduce a pause to allow

    // any dynamic input graphics to be refreshed away.

    // Otherwise get the filename (which will have its own delay)

 

    private static string PauseOrFilename(Editor ed, AppData ad)

    {

      if (ad.Clipboard)

      {

        ed.UpdateScreen();

        System.Threading.Thread.Sleep(

          (int)(1000 * ad.ClipboardCaptureDelay)

        );

        return "";

      }

      else

        return GetFileName(ed, ad);

    }

 

    // Iterate through a selection-set and get the overall extents

    // of the various objects relative to the screen

    // (this is imperfect: our extents in WCS may not translate to

    // the extents on the screen. A more thorough approach would be

    // to get a number of points from an object and check each)

 

    private static void GetExtentsOfSelection(

      Editor ed,

      Document doc,

      IntPtr hWnd,

      short vp,

      SelectionSet ss,

      out Point min,

      out Point max

    )

    {

      // Create minimum and maximum points for the "on screen"

      // extents of our objects

 

      min = new Point();

      max = new Point();

 

      // Know which is the first pass through

 

      bool first = true;

 

      // Some variables to store transformation results

 

      Point pt1 = new Point(), pt2 = new Point();

 

      Transaction tr =

        doc.TransactionManager.StartTransaction();

      using (tr)

      {

        foreach (SelectedObject so in ss)

        {

          DBObject obj =

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

          Entity ent = obj as Entity;

          if (ent != null)

          {

            // Get the WCS extents of each object

 

            Extents3d ext = ent.GeometricExtents;

 

            // Calculate the extent corners in screen coordinates

            // (this may not be the true screen extents, but we'll

            // hope it's good enough)

 

            pt1 =

              ScreenFromDrawingPoint(

                ed, hWnd, ext.MinPoint, vp, false

              );

            pt2 =

              ScreenFromDrawingPoint(

                ed, hWnd, ext.MaxPoint, vp, false

              );

 

            // The points may not be ordered, so get the min and max

            // values for both X and Y from both points

 

            int minX = Math.Min(pt1.X, pt2.X);

            int minY = Math.Min(pt1.Y, pt2.Y);

            int maxX = Math.Max(pt1.X, pt2.X);

            int maxY = Math.Max(pt1.Y, pt2.Y);

 

            // On the first run through, just get the points

 

            if (first)

            {

              min = new Point(minX, minY);

              max = new Point(maxX, maxY);

              first = false;

            }

            else

            {

              // On subsequent runs through, we need to compare

 

              if (minX < min.X) min.X = minX;

              if (minY < min.Y) min.Y = minY;

              if (maxX > max.X) max.X = maxX;

              if (maxY > max.Y) max.Y = maxY;

            }

          }

        }

        tr.Commit();

      }

    }

 

    // Apply a scale to the supplied extents

    // (provided as a potion of the extents, i.e. 10% == 0.1)

 

    private static void ApplyScaleToExtents(

      double factor,

      ref Point pt1,

      ref Point pt2

    )

    {

      // Get the width and height of the selected screen area

 

      int width = Math.Abs(pt2.X - pt1.X);

      int height = Math.Abs(pt2.Y - pt1.Y);

 

      // Decide what the (uniform) border should be: use

      // a portion of either the width or the height,

      // whichever's larger

 

      int border =

        (int)(factor * (width > height ? width : height));

 

      // Adjust the two screen points by this border amount

 

      if (pt1.X < pt2.X)

      {

        pt1.X -= border;

        pt2.X += border;

      }

      else

      {

        pt1.X += border;

        pt2.X -= border;

      }

 

      if (pt1.Y < pt2.Y)

      {

        pt1.Y -= border;

        pt2.Y += border;

      }

      else

      {

        pt1.Y += border;

        pt2.Y -= border;

      }

    }

 

    // Print the current application settings to the command-line

 

    private static void PrintSettings(Editor ed, AppData ad)

    {

      ed.WriteMessage(

        "\nCurrent settings: Output={0}, Print={1}, " +

        "Background={2}, Foreground={3}, Grayscale={4}",

        ad.Clipboard ? "Clipboard" : "File",

        ad.Print ? "Yes" : "No",

        ad.WhiteBackground ? "ForceToWhite" : "Normal",

        ad.BlackForeground ? "ForceToBlack" : "Normal",

        ad.Grayscale ? "On" : "Off"

      );

    }

 

    // Ask the user to modify the application settings

 

    private static bool GetSettings(Editor ed, AppData ad)

    {

      // At our top-level settings prompt, make the default

      // to exit back up

 

      PromptKeywordOptions pko =

        new PromptKeywordOptions(

          "\nSetting to change " +

          "[Output/Print/Background/Foreground/Grayscale/Exit]: ",

          "Output Print Background Foreground Grayscale Exit"

        );

      pko.Keywords.Default = "Exit";

 

      PromptResult pr;

      bool settingschanged = false;

      do

      {

        // Start by printing the current settings

 

        PrintSettings(ed, ad);

 

        pr = ed.GetKeywords(pko);

 

        if (pr.Status == PromptStatus.OK)

        {

          if (pr.StringResult == "Output")

          {

            // If Output is selected, ask whether to put the

            // image on the clipboard or save to file

 

            PromptKeywordOptions pko2 =

              new PromptKeywordOptions(

                "\nSave to file or place on the clipboard " +

                "[File/Clipboard]: ",

                "File Clipboard"

              );

 

            // The default depends on our current settings

 

            pko2.Keywords.Default =

              (ad.Clipboard ? "Clipboard" : "File");

 

            PromptResult pr2 = ed.GetKeywords(pko2);

 

            if (pr2.Status == PromptStatus.OK)

            {

              // Change the settings, as needed

 

              bool clipboard =

                (pr2.StringResult == "Clipboard");

 

              if (ad.Clipboard != clipboard)

              {

                ad.Clipboard = clipboard;

                settingschanged = true;

              }

            }

          }

          else if (pr.StringResult == "Print")

          {

            // If Print is different, ask whether to

            // send the image to the printer

 

            bool different =

              GetYesOrNo(

                ed,

                "\nSend image to printer once captured",

                ad.Print

              );

            if (different)

            {

              ad.Print = !ad.Print;

              settingschanged = true;

            }

          }

          else if (pr.StringResult == "Background")

          {

            // If Background is different, ask whether to

            // force the background colour to white

            // (we could allow selection of a colour,

            // but that's out of scope, for now)

 

            bool different =

              GetYesOrNo(

                ed,

                "\nForce background color to white",

                ad.WhiteBackground

              );

            if (different)

            {

              ad.WhiteBackground = !ad.WhiteBackground;

              settingschanged = true;

            }

          }

          else if (pr.StringResult == "Foreground")

          {

            // If Foreground is different, ask whether to

            // force the foreground colour to black

            // (we could allow selection of a colour,

            // but that's out of scope, for now)

 

            bool different =

              GetYesOrNo(

                ed,

                "\nForce foreground color to black",

                ad.BlackForeground

              );

            if (different)

            {

              ad.BlackForeground = !ad.BlackForeground;

              settingschanged = true;

            }

          }

          else if (pr.StringResult == "Grayscale")

          {

            // If Grayscale is different, ask whether to

            // force the foreground pixels to be gray

 

            bool different =

              GetYesOrNo(

                ed,

                "\nConvert image to grayscale",

                ad.Grayscale

              );

            if (different)

            {

              ad.Grayscale = !ad.Grayscale;

              settingschanged = true;

            }

          }

        }

      }

      while (

        pr.Status == PromptStatus.OK &&

        pr.StringResult != "Exit"

      );  // Loop until Exit or cancel

 

      return settingschanged;

    }

 

    // Ask the user to enter yes or no to a particular question,

    // setting the default option appropriately

 

    private static bool GetYesOrNo(

      Editor ed,

      string prompt,

      bool defval

    )

    {

      bool changed = false;

 

      PromptKeywordOptions pko =

        new PromptKeywordOptions(prompt + " [Yes/No]: ", "Yes No");

 

      // The default depends on our current settings

 

      pko.Keywords.Default =

        (defval ? "Yes" : "No");

      PromptResult pr = ed.GetKeywords(pko);

 

      if (pr.Status == PromptStatus.OK)

      {

        // Change the settings, as needed

 

        bool newval =

          (pr.StringResult == "Yes");

 

        if (defval != newval)

        {

          changed = true;

        }

      }

      return changed;

    }

 

    // Ask the user to select a location to save our file to

 

    private static string GetFileName(Editor ed, AppData ad)

    {

      string filename = "";

 

      // The entries here will drive the behaviour of the

      // GetFormatForFile() function

 

      PromptSaveFileOptions pofo =

        new PromptSaveFileOptions(

          "\nSelect image location: "

        );

      pofo.Filter =

        "Bitmap (*.bmp)|*.bmp|" +

        "GIF (*.gif)|*.gif|" +

        "JPEG (*.jpg)|*.jpg|" +

        "PNG (*.png)|*.png|" +

        "TIFF (*.tif)|*.tif";

 

      // Set the default save location to be the current drawing

 

      string fn = ed.Document.Database.Filename;

      if (fn.Contains("."))

      {

        int extIdx = fn.LastIndexOf(".");

        if (fn.Substring(extIdx + 1) != "dwt" &&

            fn.Contains("\\"))

        {

          int sepIdx = fn.LastIndexOf("\\");

          pofo.InitialDirectory =

            fn.Substring(0, sepIdx);

        }

      }

 

      PromptFileNameResult pfnr =

        ed.GetFileNameForSave(pofo);

 

      if (pfnr.Status == PromptStatus.OK)

      {

        filename = pfnr.StringResult;

 

        // If a file was selected, wait for some time to allow

        // the "file already exists" dialog to disappear.

        // The delay is now a configurable option (in seconds)

 

        ed.UpdateScreen();

 

        System.Threading.Thread.Sleep(

          (int)(1000 * ad.FileCaptureDelay)

        );

      }

 

      return filename;

    }

 

    // Perform our tranformations to get from UCS

    // (or WCS) to screen coordinates

 

    private static Point ScreenFromDrawingPoint(

      Editor ed,

      IntPtr hWnd,

      Point3d pt,

      short vpNum,

      bool useUcs

    )

    {

      // Transform from UCS to WCS, if needed

 

      Point3d wcsPt =

        (useUcs ?

          pt.TransformBy(ed.CurrentUserCoordinateSystem)

          : pt

        );

 

      // Then get the screen coordinates within the client

      // and translate these for the overall screen

 

      Point res = ed.PointToScreen(wcsPt, vpNum);

      ClientToScreen(hWnd, ref res);

      return res;

    }

 

    // Save the display of an AutoCAD window as a raster file

    // and/or an image on the clipboard

 

    private static void ScreenShotToFile(

      Autodesk.AutoCAD.Windows.Window wd,

      int top, int bottom, int left, int right,

      string filename,

      AppData ad

    )

    {

      Point pt = wd.Location;

      Size sz = wd.Size;

 

      pt.X += left;

      pt.Y += top;

      sz.Height -= top + bottom;

      sz.Width -= left + right;

 

      SaveScreenPortion(pt, sz, filename, ad);

    }

 

    // Save a screen window between two corners as a raster file

    // and/or an image on the clipboard

 

    private static void ScreenShotToFile(

      Point pt1,

      Point pt2,

      string filename,

      AppData ad

    )

    {

      // Create the top left corner from the two corners

      // provided (by taking the min of both X and Y values)

 

      Point pt =

        new Point(Math.Min(pt1.X, pt2.X), Math.Min(pt1.Y, pt2.Y));

 

      // Determine the size by subtracting X & Y values and

      // taking the absolute value of each

 

      Size sz =

        new Size(Math.Abs(pt1.X - pt2.X), Math.Abs(pt1.Y - pt2.Y));

 

      SaveScreenPortion(pt, sz, filename, ad);

    }

 

    // Save a portion of the screen display as a raster file

    // and/or an image on the clipboard

 

    private static void SaveScreenPortion(

      Point pt,

      Size sz,

      string filename,

      AppData ad

    )

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

      Manager gsm = doc.GraphicsManager;

 

      Transaction tr =

        db.TransactionManager.StartTransaction();

      using (tr)

      {

        AcColorSettings ocs = new AcColorSettings();

        bool gotSettings = false;

 

        ObjectId vtrId = ObjectId.Null,

                sbId = ObjectId.Null;

 

        bool in3DView = is3D(gsm);

        bool regened = false;

 

        if (ad.WhiteBackground)

        {

          if (in3DView)

          {

            Set3DBackground(

              ed,

              db,

              tr,

              new EntityColor(255, 255, 255),

              out vtrId,

              out sbId

            );

          }

          else

          {

            // Get the current system colours

 

            acedGetCurrentColors(out ocs);

            gotSettings = true;

 

            // Take a copy - we'll leave the original to reset

            // the values later on, once we've finished

 

            AcColorSettings cs = ocs;

 

            // Make both background colours white (the 3D

            // background isn't currently being picked up)

 

            cs.dwGfxModelBkColor = 16777215;

            cs.dwGfxLayoutBkColor = 16777215;

            //cs.dwParallelBkColor = 16777215;

 

            // Set the modified colours

 

            acedSetCurrentColors(ref cs);

 

            ed.WriteMessage("\n");

            ed.Regen();

            regened = true;

          }

          // Update the screen to reflect the changes

 

          ed.UpdateScreen();

        }

 

        // Set the bitmap object to the size of the window

 

        Bitmap bmp =

          new Bitmap(

            sz.Width,

            sz.Height,

            PixelFormat.Format32bppArgb

          );

        using (bmp)

        {

          // Create a graphics object from the bitmap

 

          using (Graphics gfx = Graphics.FromImage(bmp))

          {

            // Take a screenshot of our window

 

            gfx.CopyFromScreen(

              pt.X, pt.Y, 0, 0, sz,

              CopyPixelOperation.SourceCopy

            );

 

            Bitmap processed;

            if (ad.BlackForeground || ad.Grayscale)

            {

              // If we're needing to convert to a grayscale,

              // whether to create a black foreground or a

              // true grayscale image, we need to find the

              // background colour

 

              System.Drawing.Color col;

 

              // If we remapped it to white, it's easy

 

              if (ad.WhiteBackground)

              {

                col = System.Drawing.Color.White;

              }

              else

              {

                // If not, then it may be more complicated

 

                if (!gotSettings)

                {

                  acedGetCurrentColors(out ocs);

                  gotSettings = true;

                }

 

                // Get the 3D view background colour, if appropriate

 

                if (in3DView)

                {

                  uint bgcol = ocs.dwParallelBkColor;

                  col =

                    System.Drawing.Color.FromArgb((int)bgcol);

                }

                else

                {

                  // If a 2D view, we need to find out whether in

                  // modelspace or paperspace, and then get the

                  // appropriate colour for its background

 

                  bool inModelspace =

                    ((short)Application.GetSystemVariable(

                      "TILEMODE"

                    ) == 1);

                  uint bgcol =

                    (inModelspace

                      ? ocs.dwGfxModelBkColor

                      : ocs.dwGfxLayoutBkColor

                    );

                  col =

                    System.Drawing.Color.FromArgb((int)bgcol);

                }

              }

 

              // Run the conversion to a grayscale

 

              processed =

                ConvertToGrayscale(

                  bmp,

                  col,

                  ad.BlackForeground,

                  System.Drawing.Color.Black

                );

            }

            else

            {

              processed = bmp;

            }

 

            // Take a copy of the bitmap for printing

 

            using (Bitmap toPrint = processed)

            {

              // Save the screenshot to the specified location

 

              if (!regened)

                ed.WriteMessage("\n");

 

              if (filename != null && filename != "")

              {

                processed.Save(filename, GetFormatForFile(filename));

 

                ed.WriteMessage(

                  "Image captured and saved to \"{0}\".",

                  filename

                );

              }

 

              // Copy it to the clipboard

 

              if (ad.Clipboard)

              {

                System.Windows.Forms.Clipboard.SetImage(processed);

                ed.WriteMessage(

                  "Image captured to the clipboard."

                );

              }

 

              // Send it to a printer

 

              if (ad.Print)

              {

                PrintDocument pdoc = new PrintDocument();

                pdoc.PrintPage +=

                  delegate(object sender, PrintPageEventArgs e)

                  {

                    int wid = toPrint.Width,

                        hgt = toPrint.Height;

 

                    // Store the ratio between width and height

 

                    double ratio = (double)wid / (double)hgt;

 

                    // If the image's width isn't the

                    // same as the page...

 

                    if (wid != e.MarginBounds.Width)

                    {

                      // Change the width to fit the page

 

                      wid = e.MarginBounds.Width;

 

                      // Adjust the height to maintain scale

                      // (even if bigger than the page height)

 

                      hgt = (int)(wid / ratio);

                    }

 

                    // If the image's height is bigger than the

                    // page...

 

                    if (hgt > e.MarginBounds.Height)

                    {

                      // Change the height to fit the paper

 

                      hgt = e.MarginBounds.Height;

 

                      // Adjust the width to maintain scale

 

                      wid = (int)(ratio * hgt);

                    }

 

                    // Set the interpolation settings to high

                    // quality

 

                    e.Graphics.InterpolationMode =

                      InterpolationMode.HighQualityBicubic;

 

                    // And send the image out to the page

 

                    e.Graphics.DrawImage(

                      toPrint,

                      e.MarginBounds.X,

                      e.MarginBounds.Y,

                      wid,

                      hgt

                    );

                  };

 

                // Create and show the print dialog

 

                System.Windows.Forms.PrintDialog pdlg =

                  new System.Windows.Forms.PrintDialog();

                pdlg.Document = pdoc;

 

                if (pdlg.ShowDialog() ==

                    System.Windows.Forms.DialogResult.OK)

                  pdoc.Print(); // Print on OK

              }

            }

          }

        }

        if (ad.WhiteBackground)

        {

          if (vtrId != ObjectId.Null || sbId != ObjectId.Null)

          {

            Remove3DBackground(db, tr, vtrId, sbId);

          }

          else

          {

            if (gotSettings)

            {

              acedSetCurrentColors(ref ocs);

              ed.WriteMessage("\n");

              ed.Regen();

            }

          }

          ed.UpdateScreen();

        }

        tr.Commit();

      }

    }

 

    // Check whether the active viewport is 3D

 

    private static bool is3D(Manager gsm)

    {

      short vp =

        (short)Application.GetSystemVariable("CVPORT");

      View v = gsm.GetGsView(vp, false);

      using (v)

      {

        return (v != null);

      }

    }

 

    // Return the image format to use for a particular filename

 

    private static ImageFormat GetFormatForFile(string filename)

    {

      // If all else fails, let's create a PNG

      // (might also choose to throw an exception)

 

      ImageFormat imf = ImageFormat.Png;

      if (filename.Contains("."))

      {

        // Get the filename's extension (what follows the last ".")

 

        string ext =

          filename.Substring(filename.LastIndexOf(".") + 1);

 

        // Get the first three characters of the extension

 

        if (ext.Length > 3)

          ext = ext.Substring(0, 3);

 

        // Choose the format based on the extension (in lowercase)

 

        switch (ext.ToLower())

        {

          case "bmp":

            imf = ImageFormat.Bmp;

            break;

          case "gif":

            imf = ImageFormat.Gif;

            break;

          case "jpg":

            imf = ImageFormat.Jpeg;

            break;

          case "tif":

            imf = ImageFormat.Tiff;

            break;

          case "wmf":

            imf = ImageFormat.Wmf;

            break;

          default:

            imf = ImageFormat.Png;

            break;

        }

      }

      return imf;

    }

 

    // Set the background colour of a 3D view

 

    private static void Set3DBackground(

      Editor ed,

      Database db,

      Transaction tr,

      EntityColor ec,

      out ObjectId vtrId,

      out ObjectId sbId

    )

    {

      // We're be returning IDs of the Viewport Table Record

      // and of the background itself

 

      vtrId = ObjectId.Null;

      sbId = ObjectId.Null;

 

      ed.UpdateTiledViewportsInDatabase();

      ViewportTable vt =

        (ViewportTable)tr.GetObject(

          db.ViewportTableId,

          OpenMode.ForRead

        );

 

      if (vt.Has("*Active"))

      {

        // Let's get the Viewport Table Record

 

        vtrId = vt["*Active"];

        DBDictionary nod =

          (DBDictionary)tr.GetObject(

            db.NamedObjectsDictionaryId,

            OpenMode.ForRead

          );

 

        // And create the background dictionary, if none exists

 

        ObjectId bkdId = ObjectId.Null;

        DBDictionary bkDict = null;

 

        const string dictKey = "ACAD_BACKGROUND";

        const string bkKey = "ADNPlugin_Screenshot";

 

        if (nod.Contains(dictKey))

        {

          bkdId = nod.GetAt(dictKey);

          bkDict =

            (DBDictionary)tr.GetObject(bkdId, OpenMode.ForWrite);

        }

        else

        {

          bkDict = new DBDictionary();

          nod.UpgradeOpen();

          bkdId = nod.SetAt(dictKey, bkDict);

          tr.AddNewlyCreatedDBObject(bkDict, true);

        }

 

        // Get or create our background object

 

        if (bkDict.Contains(bkKey))

        {

          sbId = bkDict.GetAt(bkKey);

        }

        else

        {

          SolidBackground sb = new SolidBackground();

          sb.Color = ec;

 

          sbId = bkDict.SetAt(bkKey, sb);

          tr.AddNewlyCreatedDBObject(sb, true);

        }

 

        // And set it to the viewport

 

        ViewportTableRecord vtr =

          (ViewportTableRecord)tr.GetObject(

            vtrId,

            OpenMode.ForWrite

          );

        vtr.Background = sbId;

      }

    }

 

    // Remove the previously set 3D background colour

 

    private static void Remove3DBackground(

      Database db,

      Transaction tr,

      ObjectId vtrId,

      ObjectId sbId

    )

    {

      // First remove it from the viewport

 

      if (vtrId != ObjectId.Null)

      {

        ViewportTableRecord vtr =

          (ViewportTableRecord)tr.GetObject(

            vtrId,

            OpenMode.ForWrite

          );

        vtr.Background = ObjectId.Null;

      }

 

      // And then erase the object itself (although

      // I suspect this is redundant)

 

      if (sbId != ObjectId.Null)

      {

        SolidBackground sb =

          (SolidBackground)tr.GetObject(

            sbId,

            OpenMode.ForRead,

            true

          );

        if (!sb.IsErased)

        {

          sb.UpgradeOpen();

          sb.Erase();

        }

      }

    }

 

    // Return a grayscale version of a provided bitmap,

    // with the option of forcing non-background pixels to

    // be black

 

    public static Bitmap ConvertToGrayscale(

      Bitmap src,

      System.Drawing.Color bgcol,

      bool force,

      System.Drawing.Color fgcol

    )

    {

      // From http://www.bobpowell.net/grayscale.htm

 

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

 

      Bitmap bmp = new Bitmap(src.Width, src.Height);

      for (int y = 0; y < bmp.Height; y++)

      {

        for (int x = 0; x < bmp.Width; x++)

        {

          System.Drawing.Color c = src.GetPixel(x, y);

          int lum =

            (force && !SameColors(c, bgcol) ?

              0 :

              (int)(c.R * 0.3 + c.G * 0.59 + c.B * 0.11)

            // 0.299R + 0.587G + 0.114B

            );

          bmp.SetPixel(

            x,

            y,

            (lum == 0 ?

              fgcol :

              System.Drawing.Color.FromArgb(lum, lum, lum))

          );

        }

      }

      return bmp;

    }

 

    // Return whether two colour can be considered equivalent

    // in terms of RGB values

 

    private static bool SameColors(

      System.Drawing.Color a,

      System.Drawing.Color b

    )

    {

      // Ignore Alpha channel, just compare RGB

      return (a.R == b.R && a.G == b.G && a.B == b.B);

    }

  }

}

A new project wizard for AutoCAD .NET development

Some of you may remember a philosophical question I raised in a post some time ago. The overall consensus of the feedback we received was to prioritise delivering code samples (given a choice between code samples and wizard-like code-generation tools). Which we are doing, both via the ADN site and our developer blogs… but that doesn’t mean some investment in code-generation tools isn’t also appropriate, from time-to-time. :-)

Cyrille Fauvel, who manages the Media & Entertainment arm of DevTech but also occasionally works on technical activities that relate to our other products, has put together a new (currently draft) version of the AutoCAD .NET Wizard. This tool integrates with the Visual Studio 2008 IDE (as well as the 2008 editions of Visual C# Express and Visual Basic Express), adding C#/VB.NET project templates for AutoCAD development. (This version of the tool only works with the 2008 versions – we’re currently evaluating whether (and how) to support the 2005 versions of Visual Studio [Express] or simply to recommend using our previously posted templates.)

When you select one of these “Autodesk” project templates you will get a skeleton project that defines the application initialization protocol plus a few placeholder commands while setting up the ability to define localized commands.

Here are a few images stepping you through the installation of this Wizard (nothing very surprising, which is why I’ve kept the thumbnails so small :-):

[Note: the current installer requests an install location, which is unnecessary. The installer only uses this location for temporary files, removing them afterwards. This step will be removed from a future build of the tool.]

Once installed (and Visual Studio 2008 has been re-started), you will get some new options when you start a new project…

… that include the “AutoCAD 2010 plug-in” project template:

We’ve numbered these templates “2010”, as they provide support for API features delivered with AutoCAD 2010, but if you don’t select these features the created project should work with older versions of AutoCAD. At least that’s the theory. :-)

When you first select one of these project types, you will be asked to select the location of your ObjectARX SDK:

You should specify this along with the assemblies you would like to reference for this particular project:

On completion of this dialog your skeleton project will be created.

[Something else to note: the tool currently creates projects which allow addition of Windows Presentation Foundation content – to do this we had to add a little piece of XML to the project file that specifies a target .NET Framework version of 3.0 or above as well as a GUID to identify the project as WPF-compatible. This tells Visual Studio to list WPF item-types when you add new items to the project, but I expect this to become another configuration option in a future version as some developers will want to target framework versions where WPF is unavailable.]

Let’s take a look at the skeleton code created for a C# project, reformatted to fit the width of the blog…

First the myPlugin.cs file:

using System;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.EditorInput;

 

// This line is not mandatory, but improves loading performance

[assembly: ExtensionApplication(

  typeof(Autodesk.AutoCAD.AutoCAD_2010_plug_in1.MyPlugin)

)]

 

namespace Autodesk.AutoCAD.AutoCAD_2010_plug_in1

{

 

  // This class is instantiated by AutoCAD once and kept alive for

  // the duration of the session. If you don't do any one time

  // initialization then you should remove this class.

  public class MyPlugin : IExtensionApplication

  {

 

    void IExtensionApplication.Initialize()

    {

      // Add one time initialization here

      // One common scenario is to setup a callback function here

      // that unmanaged code can call.

      // To do this:

      // 1. Export a function from unmanaged code that takes a

      //    function pointer and stores the passed in value in a

      //    global variable.

      // 2. Call this exported function in this function passing

      //    delegate.

      // 3. When unmanaged code needs the services of this managed

      //    module you simply call acrxLoadApp() and by the time

      //    acrxLoadApp returns  global function pointer is

      //    initialized to point to the C# delegate.

      // For more info see:

      //http://msdn2.microsoft.com/en-US/library/5zwkzwf4(VS.80).aspx

      //http://msdn2.microsoft.com/en-us/library/44ey4b32(VS.80).aspx

      //http://msdn2.microsoft.com/en-US/library/7esfatk4.aspx

      // as well as some of the existing AutoCAD managed apps.

 

      // Initialize your plug-in application here

    }

 

    void IExtensionApplication.Terminate()

    {

      // Do plug-in application clean up here

    }

  }

}

And now the myCommands.cs file:

using System;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.EditorInput;

 

// This line is not mandatory, but improves loading performances

[assembly: CommandClass(

  typeof(Autodesk.AutoCAD.AutoCAD_2010_plug_in1.MyCommands)

)]

 

namespace Autodesk.AutoCAD.AutoCAD_2010_plug_in1

{

 

  // This class is instantiated by AutoCAD for each document when

  // a command is called by the user the first time in the context

  // of a given document. In other words, non static data in this

  // class is implicitly per-document!

  public class MyCommands

  {

    // The CommandMethod attribute can be applied to any public

    // member function of any public class.

    // The function should take no arguments and return nothing.

    // If the method is an intance member then the enclosing class is

    // intantiated for each document. If the member is a static

    // member then the enclosing class is NOT intantiated.

    //

    // NOTE: CommandMethod has overloads where you can provide helpid

    // and context menu.

 

    // Modal Command with localized name

    [CommandMethod(

      "MyGroup", "MyCommand", "MyCommandLocal", CommandFlags.Modal

    )]

    public void MyCommand() // This method can have any name

    {

      // Put your command code here

    }

 

    // Modal Command with pickfirst selection

    [CommandMethod(

      "MyGroup", "MyPickFirst", "MyPickFirstLocal",

      CommandFlags.Modal | CommandFlags.UsePickSet

    )]

    public void MyPickFirst() // This method can have any name

    {

      PromptSelectionResult result =

        Application.DocumentManager.MdiActiveDocument.Editor.

          SelectImplied();

      if (result.Status == PromptStatus.OK)

      {

        // There are selected entities

        // Put your command using pickfirst set code here

      }

      else

      {

        // There are no selected entities

        // Put your command code here

      }

    }

 

    // Application Session Command with localized name

    [CommandMethod(

      "MyGroup", "MySessionCmd", "MySessionCmdLocal",

      CommandFlags.Modal | CommandFlags.Session

    )]

    public void MySessionCmd() // This method can have any name

    {

      // Put your command code here

    }

 

    // LispFunction is similar to CommandMethod but it creates a

    // lisp callable function. Many return types are supported not

    // just string or integer.

    [LispFunction("MyLispFunction", "MyLispFunctionLocal")]

    public int MyLispFunction(ResultBuffer args)

    // This method can have any name

    {

      // Put your command code here

 

      // Return a value to the AutoCAD Lisp Interpreter

      return 1;

    }

  }

}

The myCommands.resx file needed to define the local command names (for the MySessionCmd command) has also been added to the project automatically to help with command localization.

All well and good… but it may be that these project templates don’t quite fit your internal needs, whether due to the copyright notices in the source and assembly properties [something I do expect to be removed from a future build – it doesn’t make sense for Autodesk copyright notices to be placed in your project skeleton] or because you have a standard approach you’ve adopted for command registration (or whatever). The good news is that it’s pretty easy for you to modify these baseline templates for your own needs:

1. Locate the template you wish to update, e.g. “C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\ProjectTemplates\CSharp\Autodesk\AutoCAD 2010 plug-in.zip” (this path will vary if you’re running on a 64-bit or localized OS or if you’re using an Express version of Visual Studio, but the technique should still work).
2. Unzip the files somewhere.
3. Modify the source code and project setup to meet your needs.
4. Modify the template file (MyTemplate.vstemplate – an XML file providing Visual Studio with additional information not stored in the project), as needed.
5. ZIP the files back up, choosing a new name for the .ZIP archive.
6. Post the file within the ProjectTemplates folder structure.
7. Run Visual Studio with the /InstallVSTemplates command parameter (the easiest way is to open a “Visual Studio 2008 Command Prompt” and use it to execute “devenv /InstallVSTemplates”).

As mentioned a few times, I do expect us to provide a new version of this tool with some minor wrinkles ironed out, but it’s pretty much ready-to-go (and certainly ready for people to try out and respond with their feedback :-). Please let us know how you get on, whether by posting a comment or by emailing our wizard developers.

Registering AutoCAD commands with localized names using .NET

While I was preparing this recent post I put together a simple project which registered localized names for commands, to make sure they were picked up and used to create the appropriate demand-loading Registry keys. It was a little tricky to do this from the current documentation, so thankfully I had access to this DevNote on the ADN site which helped a great deal (this is only available to ADN members but don’t worry if you’re not one: this post should provide equivalent information and in certain ways goes beyond the original example).

Anyway, it seemed a relevant topic to cover in its own post, so here we are today looking at this question: how to register localized command-names – possibly for multiple target languages – for your AutoCAD commands.

First of all we need to register some commands, the code for which proves to be pretty straightforward. Here’s the C# code defining our commands, which we will save in a file named Commands.cs:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.Runtime;

 

namespace LocalizedCommands

{

  public class LocCmds

  {

    [CommandMethod(

      "LOCCMDS", "HELLO", "helloCmdId", CommandFlags.Modal

    )]

    public void HelloCommand()

    {

      Application.DocumentManager.MdiActiveDocument.Editor.

        WriteMessage("\nHello!");

    }

 

    [CommandMethod(

      "LOCCMDS", "GOODBYE", "goodbyeCmdId", CommandFlags.Modal

    )]

    public void GoodbyeCommand()

    {

      Application.DocumentManager.MdiActiveDocument.Editor.

        WriteMessage("\nGoodbye!");

    }

  }

}

You’ll notice straight away that we’re using a special version of the CommandMethod attribute which specifies more than the usual items (command name and flags are the most common ones). We start with the command group (“LOCCMDS”), the global names (“HELLO” and “GOODBYE”), the localized resource IDs (“helloCmdId” and “goodbyeCmdId”) and then come the flags (CommandFlags.Modal).

The localized command name is provided as a resource ID to aid localization. Let’s see how this helps… we’ll add some resources to the project for our neutral culture (US English) and for two additional cultures (French and German).

We can add resource files by right-clicking the project and selecting Add –> New Item:

From here we can use the Add New Item dialog to add new resource files with the names “Commands.resx” (which is for the neutral culture, US English), “Commands.fr-FR.resx” and “Commands.de-DE.resx” (these three files will need to be added one-by-one). It’s important that the resource files use the same base name as the .cs file (they do not have to use the class name – LocCmds – and, in fact, you may run into name collisions if you attempt to do so).

 

So far, so good. We should now see the resultant files in our solution explorer, and be able to open them by double-clicking them.

The files will be blank initially, and we will want to add two string resources to each, one for each of our commands, using the IDs “helloCmdId” and “goodbyeCmdId”.

 

 

When we come to edit the individual string resources, we may be presented with a warning dialog (it is safe to select Yes):

 

Now we can go ahead and add localized string resources for our two commands in each of the three cultures:

It should now be possible to build our application. If we take a look at the output folder, we should see sub-folders for each of our cultures:

The en-US folder will be empty, as we’ve included that as our base culture, but the other two will contain resource DLLs (also known as satellite assemblies) containing our localized strings for that target culture.

Now to see these in action. In order to fake the loading of our assembly into different language versions of AutoCAD, I put together a simple application to change the UI culture (the one used by the resource manager to choose the resources to load) of the current thread. This clearly needs to be in a separate assembly, as we want to change the culture before we use NETLOAD to load the assembly containing our localized commands.

Here’s the C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.Runtime;

using System.Threading;

using System.Globalization;

 

namespace CultureShift

{

  public class Commands

  {

    private void setCulture(string culture)

    {

      Thread.CurrentThread.CurrentUICulture =

        new CultureInfo(culture);

    }

 

    private void setNeutralCulture(string neutCult)

    {

      Thread.CurrentThread.CurrentUICulture =

        CultureInfo.CreateSpecificCulture(neutCult);

    }

 

    [CommandMethod("SETFR")]

    public void SetFrenchCulture()

    {

      setNeutralCulture("fr"); // or setCulture("fr-FR");

      GetCulture();

    }

 

    [CommandMethod("SETDE")]

    public void SetGermanCulture()

    {

      setNeutralCulture("de"); // or setCulture("de-DE");

      GetCulture();

    }

 

    [CommandMethod("SETEN")]

    public void SetEnglishCulture()

    {

      setNeutralCulture("en"); // or setCulture("en-US");

      GetCulture();

    }

 

    [CommandMethod("GETCUL")]

    public void GetCulture()

    {

      Application.DocumentManager.MdiActiveDocument.Editor.

        WriteMessage(

          "\nCurrent UI culture is {0}.",

          Thread.CurrentThread.CurrentUICulture.Name

        );

    }

  }

}

This code implements a number of commands to set the UI culture to US English (SETEN), French (SETFR) and German (SETDE) as well as to check the current UI culture (GETCUL). The code chooses to set the culture neutrally – which sets the language but not the location – but the end result is the same for the cultures we’ve chosen. One thing to bear in mind: this code only actually works if running from the debugger. It doesn’t crash, otherwise, but the current UI culture always ends up as “en-US”. I assume this is a threading issue, but as this is really only for testing purposes it’s a tolerable requirement to run everything from the debugger.

Here’s what happens when (launching AutoCAD from the Visual Studio 2009 debugger) we load our test code, set the current UI culture to French and then load the main application, checking which commands work and which do not:

Command: NETLOAD

Command: GETCUL

Current UI culture is en-US.

Command: SETFR

Current UI culture is fr-FR.

Command: GETCUL

Current UI culture is fr-FR.

Command: NETLOAD

Command: HELLO

Hello!

Command: GOODBYE

Goodbye!

Command: BONJOUR

Hello!

Command: AUREVOIR

Goodbye!

Command: GUTENTAG Unknown command "GUTENTAG".  Press F1 for help.

Command: BYE Unknown command "BYE".  Press F1 for help.

We can see that the global and the French-localized commands have indeed worked, while the German and US ones have not.

Let’s do the same for German:

Command: NETLOAD

Command: GETCUL

Current UI culture is en-US.

Command: SETDE

Current UI culture is de-DE.

Command: GETCUL

Current UI culture is de-DE.

Command: NETLOAD

Command: HELLO

Hello!

Command: GOODBYE

Goodbye!

Command: BONJOUR Unknown command "BONJOUR".  Press F1 for help.

Command: GUTENTAG

Hello!

Command: AUFWIEDERSEHEN

Goodbye!

Command: BYE Unknown command "BYE".  Press F1 for help.

And sure enough, while the German and global commands work, the others do not.

For completeness, if we just load our application – without either launching from the debugger or loading our test application to change the current UI culture – and run the commands, here’s what we see:

Command: NETLOAD

Command: HELLO

Hello!

Command: GOODBYE

Goodbye!

Command: HI

Hello!

Command: BYE

Goodbye!

Command: BONJOUR Unknown command "BONJOUR".  Press F1 for help.

Command: AUREVOIR Unknown command "AUREVOIR".  Press F1 for help.

Command: GUTENTAG Unknown command "GUTENTAG".  Press F1 for help.

Command: AUFWIEDERSEHEN Unknown command "AUFWIEDERSEHEN".  Press F1 for help.

My assumption is that the current UI culture will be set appropriately in the different language versions of AutoCAD, and so the localized resources will be chosen correctly. If someone trying the technique for real were able to confirm, I'd certainly appreciate it. :-)

Creating demand-loading entries automatically for your AutoCAD application using .NET

Here’s a question I received recently by email:

How do you set up a .NET plugin for AutoCAD to install & demand load in the same way as ObjectARX plugins? The documentation is not very clear at making the distinctions visible.

In ARX terms, we currently write a set of registry entries as part of our installer, along with refreshing these via an AcadAppInfo registration during ARX load. The ARX itself can be located anywhere as long as the registry entries point to it. I’m not sure of the correct procedure for .NET plugins to duplicate this.

Augusto Gonçalves, from our DevTech Americas team, provided a solution for this which showed how to create demand-loading Registry keys programmatically based on the current assembly’s name and location. It occurred to me that extending the code to make further use of reflection to query the commands defined by an assembly would make this really interesting, and could essentially create a very flexible approach for creation of a demand-loading entries as an application initializes or during execution of a custom command.

Here’s the C# code:

using System.Collections.Generic;

using System.Reflection;

using System.Resources;

using System;

using Microsoft.Win32;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.Runtime;

 

namespace DemandLoading

{

  public class RegistryUpdate

  {

    public static void RegisterForDemandLoading()

    {

      // Get the assembly, its name and location

 

      Assembly assem = Assembly.GetExecutingAssembly();

      string name = assem.GetName().Name;

      string path = 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)

 

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

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

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

 

      // Iterate through the modules in the assembly

 

      Module[] mods = assem.GetModules(true);

      foreach(Module mod in mods)

      {

        // Within each module, iterate through the types

 

        Type[] types = mod.GetTypes();

        foreach (Type type in types)

        {

          // We may need to get a type's resources

 

          ResourceManager rm =

            new ResourceManager(type.FullName, assem);

          rm.IgnoreCase = true;

 

          // Get each method on a type

 

          MethodInfo[] meths = type.GetMethods();

          foreach (MethodInfo meth in meths)

          {

            // Get the methods custom command attribute(s)

 

            object[] attbs =

              meth.GetCustomAttributes(

                typeof(CommandMethodAttribute),

                true

              );

            foreach (object attb in attbs)

            {

              CommandMethodAttribute cma =

                attb as CommandMethodAttribute;

              if (cma != null)

              {

                // And we can finally harvest the information

                // about each command

 

                string globName = cma.GlobalName;

                string locName = globName;

                string lid = cma.LocalizedNameId;

 

                // If we have a localized command ID,

                // let's look it up in our resources

 

                if (lid != null)

                {

                  // 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

                  {}

                }

 

                // Add the information to our data structures

 

                globCmds.Add(globName);

                locCmds.Add(locName);

 

                if (cma.GroupName != null &&

                    !groups.Contains(cma.GroupName))

                  groups.Add(cma.GroupName);

              }

            }

          }

        }

      }

 

      // Let's register the application to load on demand (12)

      // if it contains commands, otherwise we will have it

      // load on AutoCAD startup (2)

 

      int flags = (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

      );

    }

 

    public static void UnregisterForDemandLoading()

    {

      RemoveDemandLoadingEntries(true);

    }

 

    // Helper functions

 

    private static void CreateDemandLoadingEntries(

      string name,

      string path,

      List<string> globCmds,

      List<string> locCmds,

      List<string> groups,

      int flags,

      bool currentUser

    )

    {

      // Choose a Registry hive based on the function input

 

      RegistryKey hive =

        (currentUser ? Registry.CurrentUser : Registry.LocalMachine);

 

      // Open the main AutoCAD (or vertical) and "Applications" keys

 

      RegistryKey ack =

        hive.OpenSubKey(

          HostApplicationServices.Current.RegistryProductRootKey

        );

      RegistryKey appk =

        ack.OpenSubKey("Applications", true);

 

      // Already registered? Just return

 

      string[] subKeys = appk.GetSubKeyNames();

      foreach (string subKey in subKeys)

      {

        if (subKey.Equals(name))

        {

          appk.Close();

          return;

        }

      }

 

      // Create the our application's root key and its values

 

      RegistryKey rk =

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

          globCmds.Count > 0)

      {

        RegistryKey ck =

          rk.CreateSubKey("Commands");

 

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

          ck.SetValue(

            globCmds[i],

            locCmds[i],

            RegistryValueKind.String

          );

      }

 

      // And the command groups, if there are any

 

      if (groups.Count > 0)

      {

        RegistryKey gk =

          rk.CreateSubKey("Groups");

 

        foreach (string grpName in groups)

          gk.SetValue(grpName, grpName, RegistryValueKind.String);

      }

 

      appk.Close();

    }

 

    private static void RemoveDemandLoadingEntries(bool currentUser)

    {

      // Choose a Registry hive based on the function input

 

      RegistryKey hive =

        (currentUser ? Registry.CurrentUser : Registry.LocalMachine);

 

      // Open the main AutoCAD (or vertical) and "Applications" keys

 

      RegistryKey ack =

        hive.OpenSubKey(

          HostApplicationServices.Current.RegistryProductRootKey

        );

      RegistryKey appk =

        ack.OpenSubKey("Applications", true);

 

      // Delete the key with the same name as this assembly

 

      appk.DeleteSubKeyTree(

        Assembly.GetExecutingAssembly().GetName().Name

      );

      appk.Close();

    }

  }

}

If you drop this code into an existing project, you should be able simply to add a call to DemandLoading.RegistryUpdate.RegisterForDemandLoading() during your IExtensionApplication’s Initialize() method or during a custom command.

Here’s an example of the Registry keys created by this code (exported from Regedit) when called from the Initialize() method of the application in this previous post:

Windows Registry Editor Version 5.00

 

[HKEY_CURRENT_USER\Software\Autodesk\AutoCAD\R18.0\ACAD-8001:409\Applications\OffsetInXref]

"DESCRIPTION"="OffsetInXref"

"LOADCTRLS"=dword:0000000c

"LOADER"="C:\\Program Files\\Autodesk\\AutoCAD 2010\\OffsetInXref.dll"

"MANAGED"=dword:00000001

 

[HKEY_CURRENT_USER\Software\Autodesk\AutoCAD\R18.0\ACAD-8001:409\Applications\OffsetInXref\Commands]

"XOFFSETLAYER"="XOFFSETLAYER"

"XOFFSETCPLAYS"="XOFFSETCPLAYS"

 

You can see that our code found the commands defined by the application and created Registry entries which tell AutoCAD to load the module when one of them is chosen by the user. You’ll notice the LOADCTRLS value is c (hexadecimal for 12), which means the application will be loaded “on demand” as a specified command is invoked, but we could also adjust the code to force this to 2, which would mean the module would be loaded on AutoCAD startup (the default when no commands are found). This would actually be a good idea, in this case, as the command hooks into the OFFSET command, and we can’t demand-load a module on invocation of a built-in command.

You’ll also notice that the keys were created under R18.0\ACAD-8001:409 (the English version of AutoCAD 2010), but if the module was loaded in a different language version of an AutoCAD-based vertical product (French AutoCAD Architecture 2009, for instance) then the root key would be the one for that product. All you have to do is load the module once in the AutoCAD-based product of your choice, and it will be registered for automatic loading from then onwards.

This is a useful technique for people who want to deploy .NET modules without installers, or for people who wish applications to re-create their demand-loading keys on load (something this code currently does not do, by the way: if the application’s key is found we do not recreate the contents for the sake of efficiency… you may want to change the code to force creation of the keys should you be adding new commands regularly to your application, for instance).

Interfacing an external COM application with a .NET module in-process to AutoCAD (redux)

Thanks to all of your interest in this recent post, which looked at a way to interface an out-of-process .NET application with an assembly running in-process to AutoCAD. After some obvious functionality gaps were raised, Renze de Waal, one of our ADN members, pointed out a DevNote on the ADN website covering – and more completely addressing – this topic. Shame on me for not checking there before writing the post. Anyway, onwards and upwards…

The information in the DevNote highlights some of the problems I and other people had hit with my previous code, mostly related to the fact it wasn’t executed on the main AutoCAD thread (which meant we were effectively limited in the interactions we had with the AutoCAD application).

To fix this we can derive our application from System.EnterpriseServices.ServicedComponent (also adding an additional project reference to the System.EnterpriseServices .NET assembly). Here is the updated C# code for the LoadableComponent:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Geometry;

using System.Runtime.InteropServices;

using System.EnterpriseServices;

 

namespace LoadableComponent

{

  [Guid("5B5B731C-B37A-4aa2-8E50-42192BD51B17")]

  public interface INumberAddition

  {

    [DispId(1)]

    string AddNumbers(int arg1, double arg2);

  }

 

  [ProgId("LoadableComponent.Commands"),

   Guid("44D8782B-3F60-4cae-B14D-FA060E8A4D01"),

   ClassInterface(ClassInterfaceType.None)]

  public class Commands : ServicedComponent, INumberAddition

  {

    // A simple test command, just to see that commands

    // are loaded properly from the assembly

 

    [CommandMethod("MYCOMMAND")]

    static public void MyCommand()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

      ed.WriteMessage("\nTest command executed.");

    }

 

    // A function to add two numbers and create a

    // circle of that radius. It returns a string

    // withthe result of the addition, just to use

    // a different return type

 

    public string AddNumbers(int arg1, double arg2)

    {     

      // During tests it proved unreliable to rely

      // on DocumentManager.MdiActiveDocument

      // (which was null) so we will go from the

      // HostApplicationServices' WorkingDatabase

 

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

 

      ed.WriteMessage(

        "\nAdd numbers called with {0} and {1}.",

        arg1, arg2

      );

 

      // Perform our addition

 

      double res = arg1 + arg2;

 

      // Lock the document before we access it

 

      DocumentLock loc = doc.LockDocument();

      using (loc)

      {

        Transaction tr =

          db.TransactionManager.StartTransaction();

        using (tr)

        {

          // Create our circle

 

          Circle cir =

            new Circle(

              new Point3d(0, 0, 0),

              new Vector3d(0, 0, 1),

              res

            );

 

          cir.SetDatabaseDefaults(db);

 

          // Add it to the current space

 

          BlockTableRecord btr =

            (BlockTableRecord)tr.GetObject(

              db.CurrentSpaceId,

              OpenMode.ForWrite

            );

          btr.AppendEntity(cir);

          tr.AddNewlyCreatedDBObject(cir, true);

 

          // Commit the transaction

 

          tr.Commit();

        }

      }

 

      // Return our string result

 

      return res.ToString();

    }

  }

}

Some points to note...

• We now use an interface to expose functionality from our component, which allows us more flexibility in the way we return data to the calling application.
• We're labeling our interface and component with specific GUIDs - generated by guidgen.exe - although we could probably skip this step.
• We're now able to use the MdiActiveDocument property safely, as well as being able to write messages via the editor.

When we build the component we can - as before - register it via the regasm.exe tool. Here's the .reg output if you specify the /regfile option:

REGEDIT4

 

[HKEY_CLASSES_ROOT\LoadableComponent.Commands]

@="LoadableComponent.Commands"

 

[HKEY_CLASSES_ROOT\LoadableComponent.Commands\CLSID]

@="{44D8782B-3F60-4CAE-B14D-FA060E8A4D01}"

 

[HKEY_CLASSES_ROOT\CLSID\{44D8782B-3F60-4CAE-B14D-FA060E8A4D01}]

@="LoadableComponent.Commands"

 

[HKEY_CLASSES_ROOT\CLSID\{44D8782B-3F60-4CAE-B14D-FA060E8A4D01}\InprocServer32]

@="mscoree.dll"

"ThreadingModel"="Both"

"Class"="LoadableComponent.Commands"

"Assembly"="LoadableComponent, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"

"RuntimeVersion"="v2.0.50727"

 

[HKEY_CLASSES_ROOT\CLSID\{44D8782B-3F60-4CAE-B14D-FA060E8A4D01}\InprocServer32\1.0.0.0]

"Class"="LoadableComponent.Commands"

"Assembly"="LoadableComponent, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"

"RuntimeVersion"="v2.0.50727"

 

[HKEY_CLASSES_ROOT\CLSID\{44D8782B-3F60-4CAE-B14D-FA060E8A4D01}\ProgId]

@="LoadableComponent.Commands"

 

[HKEY_CLASSES_ROOT\CLSID\{44D8782B-3F60-4CAE-B14D-FA060E8A4D01}\Implemented Categories\{62C8FE65-4EBB-45E7-B440-6E39B2CDBF29}]

One thing to mention - I found that the calling application was not able to to cast the returned System.__COMObject to LoadableComponent.INumberAddition unless I updated the project settings to "Register from COM Interop" (near the bottom of the Build tab).

Now for our calling application… here’s the updated C# code:

using Autodesk.AutoCAD.Interop;

using System.Windows.Forms;

using System.Runtime.InteropServices;

using System.Reflection;

using System;

using LoadableComponent;

 

namespace DrivingAutoCAD

{

  public partial class Form1 : Form

  {

    public Form1()

    {

      InitializeComponent();

    }

 

    private void button1_Click(object sender, EventArgs e)

    {

      const string progID = "AutoCAD.Application.18";

 

      AcadApplication acApp = null;

      try

      {

        acApp =

          (AcadApplication)Marshal.GetActiveObject(progID);

      }

      catch

      {

        try

        {

          Type acType =

            Type.GetTypeFromProgID(progID);

          acApp =

            (AcadApplication)Activator.CreateInstance(

              acType,

              true

            );

        }

        catch

        {

          MessageBox.Show(

            "Cannot create object of type \"" +

            progID + "\""

          );

        }

      }

      if (acApp != null)

      {

        try

        {

          // By the time this is reached AutoCAD is fully

          // functional and can be interacted with through code

 

          acApp.Visible = true;

 

          INumberAddition app =

            (INumberAddition)acApp.GetInterfaceObject(

              "LoadableComponent.Commands"

            );

 

          // Now let's call our method

 

          string res = app.AddNumbers(5, 6.3);

 

          acApp.ZoomAll();

 

          MessageBox.Show(

            this,

            "AddNumbers returned: " + res

          );

        }

        catch (Exception ex)

        {

          MessageBox.Show(

            this,

            "Problem executing component: " +

            ex.Message

          );

        }

      }

    }

  }

}

You should be able to see straightaway that it’s simpler – we cast the results of the GetInterfaceObject call to our interface and call the AddNumbers method on it.

And when we execute the code, we can see we’re now able to write to the command-line, as well as getting better results from our ZoomAll():

Interfacing an external COM application with a .NET module in-process to AutoCAD

This question came in recently by email from Michael Fichter of Superstructures Engineers and Architects:

Could you suggest an approach that would enable me to drive a .NET function (via COM) that could return a value from .NET back to COM? I have used SendCommand in certain instances where return values were not needed.

Michael’s referring to a technique used in this previous post, which shows how to launch AutoCAD from a .NET executable via COM and then launch a command which can then safely interface with AutoCAD in-process via its managed API.

And yes, this technique is fine if you don’t want to return results, but has limitations if you do. You could populate AutoCAD user variables or create a file for the calling application to read but such approaches are cumbersome.

So… in spite of my initial doubtful reaction I decided to give it a try. Here are the steps I used to get this working…

First we create a Class Library for our in-process component with references to the usual acmgd.dll and acdbmgd.dll assemblies, adding the following C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Geometry;

using System.Runtime.InteropServices;

 

namespace LoadableComponent

{

  [ProgId("LoadableComponent.Commands")]

  public class Commands

  {

    // A simple test command, just to see that commands

    // are loaded properly from the assembly

 

    [CommandMethod("MYCOMMAND")]

    public void MyCommand()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

      ed.WriteMessage("\nTest command executed.");

    }

 

    // A function to add two numbers and create a

    // circle of that radius. It returns a string

    // withthe result of the addition, just to use

    // a different return type

 

    public string AddNumbers(int arg1, double arg2)

    {

      // During tests it proved unreliable to rely

      // on DocumentManager.MdiActiveDocument

      // (which was null) so we will go from the

      // HostApplicationServices' WorkingDatabase

 

      Database db =

        HostApplicationServices.WorkingDatabase;

      Document doc =

        Application.DocumentManager.GetDocument(db);

 

      // Perform our addition

 

      double res = arg1 + arg2;

 

      // Lock the document before we access it

 

      DocumentLock loc = doc.LockDocument();

      using (loc)

      {

        Transaction tr =

          db.TransactionManager.StartTransaction();

        using (tr)

        {

          // Create our circle

 

          Circle cir =

            new Circle(

              new Point3d(0, 0, 0),

              new Vector3d(0, 0, 1),

              res

            );

 

          cir.SetDatabaseDefaults(db);

 

          // Add it to the current space

 

          BlockTableRecord btr =

            (BlockTableRecord)tr.GetObject(

              db.CurrentSpaceId,

              OpenMode.ForWrite

            );

          btr.AppendEntity(cir);

          tr.AddNewlyCreatedDBObject(cir, true);

 

          // Commit the transaction

 

          tr.Commit();

        }

      }

 

      // Return our string result

 

      return res.ToString();

    }

  }

}

You’ll see we mark our Commands class as having the ProgId of “LoadableComponent.Commands” (this doesn’t have to follow the namespace.class-name convention, if you’d rather use something else). Be sure to edit the AssemblyInfo.cs file to make sure the ComVisible assembly attribute is set to true (the default is false), otherwise no classes will be exposed via COM.

The code is mostly pretty simple… it includes a command just to make sure commands are registered when the assembly loads. The AddNumbers() function uses a slightly different technique to get the working database and its document, mainly because I found MdiActiveDocument to be null when I needed it. I suspect this is simply a timing issue, and that if AutoCAD had the time to fully initialize we wouldn’t have to code this defensively. There may well be a clean way to wait for this to happen (comments, anyone?).

Once we’ve built the assembly it needs to be registered via COM. The way I tend to do this is via a “Visual Studio Command Prompt” (which has the path set nicely to call the VS development tools). I browse to the location of my assembly and then run “regasm LoadableComponent.dll” (you can specify the optional /reg parameter if you’d rather create a .reg file rather than modifying the Registry directly).

Now we can create an executable project to drive this component with COM references to the AutoCAD Type Library (I’m using the one for AutoCAD 2010) and the AutoCAD/ObjectDBX Common Type Library (AutoCAD 2010’s is version 18.0), as well as a reference to our .NET assembly (which I have called LoadableComponent.dll).

Inside the default form created with the executable project we can add a button behind which we copy the code in the post referred to earlier, adding some logic to load our component and dynamically execute its AddNumbers() function:

using Autodesk.AutoCAD.Interop;

using System.Windows.Forms;

using System.Runtime.InteropServices;

using System.Reflection;

using System;

using LoadableComponent;

 

namespace DrivingAutoCAD

{

  public partial class Form1 : Form

  {

    public Form1()

    {

      InitializeComponent();

    }

 

    private void button1_Click(object sender, EventArgs e)

    {

      const string progID = "AutoCAD.Application.18";

 

      AcadApplication acApp = null;

      try

      {

        acApp =

          (AcadApplication)Marshal.GetActiveObject(progID);

      }

      catch

      {

        try

        {

          Type acType =

            Type.GetTypeFromProgID(progID);

          acApp =

            (AcadApplication)Activator.CreateInstance(

              acType,

              true

            );

        }

        catch

        {

          MessageBox.Show(

            "Cannot create object of type \"" +

            progID + "\""

          );

        }

      }

      if (acApp != null)

      {

        try

        {

          // By the time this is reached AutoCAD is fully

          // functional and can be interacted with through code

 

          acApp.Visible = true;

 

          object app =

            acApp.GetInterfaceObject("LoadableComponent.Commands");

 

          if (app != null)

          {

            // Let's generate the arguments to pass in:

            // an integer and a double

 

            object[] args = { 5, 6.3 };

 

            // Now let's call our method dynamically

 

            object res =

              app.GetType().InvokeMember(

                "AddNumbers",

                BindingFlags.InvokeMethod,

                null,

                app,

                args

              );

            acApp.ZoomAll();

            MessageBox.Show(

              this,

              "AddNumbers returned: " + res.ToString()

            );

          }

        }

        catch (Exception ex)

        {

          MessageBox.Show(

            this,

            "Problem executing component: " +

            ex.Message

          );

        }

      }

    }

  }

}

I decided to try Application.GetInterfaceObject() – the classic way to load an old VB6 ActiveX DLL into AutoCAD from VBA or Visual LISP – to see whether it worked for .NET assemblies that have a ProgId assigned. It not only worked, but the commands contained within the module were registered properly. A nice surprise! :-)

I started by defining an interface in the Class Library to be used in the Executable, but ended up going with a more dynamic approach, using InvokeMember() on the class of the object returned by GetInterfaceObject(). This avoids having to define and cast to the interface but adds a little uncertainty to the operation (as I’ve mentioned a number of times in recent weeks when we start getting dynamic we lose most of the compiler crutches we’ve all become used to :-). I also hit a problem if the command function was declared as static, but presumably that can be resolved with the right arguments to InvokeMember().

When we run this code and select the button, we see a circle get created with the radius of 11.3, the result of adding the integer (5) and double (6.3) we passed to the AddNumbers() function:

The combination of COM for out-of-process control with .NET for in-process power and performance will hopefully be a useful technique for many of you needing to automate AutoCAD from an external executable. Be sure to post comments if any of you have things to share on this topic. Thanks for the question, Michael! :-)

Update:

A much-improved implementation of this application can be found in this post.

Using IronPython with AutoCAD

I’ve been meaning to play around with the Python language for some time, now, and with the recent release of IronPython 2 it seems a good time to start.

Why Python? A number of people in my team – including Jeremy Tammik and the people within our Media  & Entertainment workgroup who support Python’s use with Maya and MotionBuilder – are fierce proponents of the language. I’m told that it’s an extremely easy, general-purpose, dynamic programming language. All of which sounds interesting, of course, although I have to admit I’m less convinced of the importance of the dynamic piece: I’ve found a lot of value in static typing over the years (even F# is statically typed, although many people – even some who work with it - don’t realise this… its type inference system allows you to code safely without specifying types all over the place).

Let’s take a quick step back and talk about what makes a language dynamic. The most common example of a dynamic language – one that I’m sure most of you will have touched at some point – is JavaScript. In JavaScript you declare everything as a var, assign it, call methods on it and hope that they work at runtime. I admit that I’ve always disliked developing in JavaScript because of the lack of decent tool support: I’m a big fan of Intellisense (based on an object’s design-time type) and want the compiler to tell me if I’m dealing with an object that doesn’t support a particular method. But perhaps that’s largely what I’ve become used to from modern development tools, and I’m trying to remain open to new things. Really, I am.

Another dynamic language with which I’ve had much more favourable (but still, at times, frustrating) experiences is LISP. But my relationship with LISP is different: like most early AutoCAD programmers I adopted it out of necessity – and at the time I started with it programming environments were, in any case, generally very basic - I then grew to love it and have since never forgotten it, even when more attractive/productive development environments came along. So I’m extremely loathe to paint it with the same brush as the one I’ve used for JavaScript.

Python is also of interest because of its cross-platform availability: it’s an open source language with its roots in the UNIX/Linux world, but is now gaining popularity across a variety of OS platforms (one of the reasons it’s the scripting language chosen for at least one of our cross-platform products, Autodesk Maya).

Microsoft is definitely now very open to the possibilities of dynamic languages: they’re making a significant investment in the Dynamic Language Runtime, to support languages such as IronPython and IronRuby, as well as adding more dynamic features with C# 4.0 (which is finally going to get something comparable to VB’s “late binding” capability).

So all in all, the world we live in seems to be becoming increasingly dynamic. :-)

Anyway – now on to getting IronPython working with AutoCAD. I had originally hoped to build a .NET assembly directly using IronPython – something that appears to have been enabled with the 2.0 release of IronPython - which could then be loaded into AutoCAD. Unfortunately this was an exercise in frustration: AutoCAD makes heavy use of custom attributes for identifying commands etc., but IronPython doesn’t currently support the use of attributes. It is possible to do some clever stuff by compiling attributed C# on-the-fly and deriving classes from it (information on this is available here), which will – in theory, at least – get you something in memory that’s attributed but, as AutoCAD scans the physical assembly for custom attributes before loading it, this didn’t help. I also spent a great deal of time just trying to derive a class from Autodesk.AutoCAD.Runtime.IExtensionApplication – to have the Initialize() function called automatically on load – but I just couldn’t get this to work, either.

Then, thankfully, Tim Riley came to the rescue: we’ve been in touch on and off over the years since he started the PyAcad.NET project to run IronPython code inside AutoCAD, and Tim was able to put together some working code which actually registered commands (after I’d pointed him at a function he could use from AutoCAD 2009’s acmgdinternal.dll – an unsupported assembly that exposes some otherwise quite helpful functions). He ended up choosing an implementation that had also been suggested to me by Albert Szilvasy: to implement a PYLOAD command using C# which allows selection and loading of a Python script (because Python is, ultimately, all about scripting rather than building static, compiled assemblies).

Before we get on to the C# module, I should point out that I installed IronPython 2.0.1 as well as IronPython Studio 1.0 for the Visual Studio 2008 integration. It turns out that as we’re relying on C# to manage the loading of Python – rather than compiling a .NET assembly – the main advantage of IronPython Studio is around the ability to work with Python source code inside Visual Studio.

To build the below C# code into a standard .NET Class Library assembly (a .DLL) you’ll need to add assembly references to IronPython.dll, IronPython.Modules.dll, Microsoft.Scripting.dll and Microsoft.Scripting.Core.dll – all of which can be found in the main IronPython install folder (on my system this is in “C:\Program Files\IronPython 2.0.1”). As well as the standard references to acmgd.dll and acdbmgd.dll, of course.

Here’s the C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.EditorInput;

using IronPython.Hosting;

using Microsoft.Scripting.Hosting;

using System;

 

namespace PythonLoader

{

  public class CommandsAndFunctions

  {

    [CommandMethod("-PYLOAD")]

    public static void PythonLoadCmdLine()

    {

      PythonLoad(true);

    }

 

    [CommandMethod("PYLOAD")]

    public static void PythonLoadUI()

    {

      PythonLoad(false);

    }

 

    public static void PythonLoad(bool useCmdLine)

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

 

      short fd =

        (short)Application.GetSystemVariable("FILEDIA");

 

      // As the user to select a .py file

 

      PromptOpenFileOptions pfo =

          new PromptOpenFileOptions(

            "Select Python script to load"

          );

      pfo.Filter = "Python script (*.py)|*.py";

      pfo.PreferCommandLine =

        (useCmdLine || fd == 0);

      PromptFileNameResult pr =

        ed.GetFileNameForOpen(pfo);

 

      // And then try to load and execute it

 

      if (pr.Status == PromptStatus.OK)

        ExecutePythonScript(pr.StringResult);

    }

 

    [LispFunction("PYLOAD")]

    public ResultBuffer PythonLoadLISP(ResultBuffer rb)

    {

      const int RTSTR = 5005;

 

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

 

      if (rb == null)

      {

        ed.WriteMessage("\nError: too few arguments\n");

      }

      else

      {

        // We're only really interested in the first argument

 

        Array args = rb.AsArray();

        TypedValue tv = (TypedValue)args.GetValue(0);

 

        // Which should be the filename of our script

 

        if (tv != null && tv.TypeCode == RTSTR)

        {

          // If we manage to execute it, let's return the

          // filename as the result of the function

          // (just as (arxload) does)

 

          bool success =

            ExecutePythonScript(Convert.ToString(tv.Value));

          return

            (success ?

              new ResultBuffer(

                new TypedValue(RTSTR, tv.Value)

              )

              : null);

        }

      }

      return null;

    }

 

    private static bool ExecutePythonScript(string file)

    {

      // If the file exists, let's load and execute it

      // (we could/should probably add some more robust

      // exception handling here)

 

      bool ret = System.IO.File.Exists(file);

      if (ret)

      {

        ScriptEngine engine = Python.CreateEngine();

        engine.ExecuteFile(file);

      }

      return ret;

    }

  }

}

The code behind the PYLOAD command is actually really simple. I could have kept it basic but decided it would be a good opportunity to show some best practices. So not only do we have the standard PYLOAD command, which respects the FILEDIA variable to decide whether to use dialogs or the command-line, we also have a command-line version –PYLOAD and a LISP function (pyload). All of which call into the same function to load a Python script.

OK, now let’s take a look at a simple IronPython script that calls into AutoCAD via its .NET API. Thanks again to Tim Riley for providing something that works. Even with Python being (apparently) so easy to learn, I’m such a neophyte that without his help I’d still be stumbling around in the dark.

import clr

path = 'C:\\Program Files\\Autodesk\\AutoCAD 2009\\'

clr.AddReferenceToFileAndPath(path + 'acdbmgd.dll')

clr.AddReferenceToFileAndPath(path + 'acmgd.dll')

clr.AddReferenceToFileAndPath(path + 'acmgdinternal.dll')

 

import Autodesk

import Autodesk.AutoCAD.Runtime as ar

import Autodesk.AutoCAD.ApplicationServices as aas

import Autodesk.AutoCAD.DatabaseServices as ads

import Autodesk.AutoCAD.Geometry as ag

import Autodesk.AutoCAD.Internal as ai

from Autodesk.AutoCAD.Internal import Utils

 

# Function to register AutoCAD commands

# To be used via a function decorator

 

def autocad_command(function):

 

    # First query the function name

    n = function.__name__

 

    # Create the callback and add the command

    cc = ai.CommandCallback(function)

    Utils.AddCommand('pycmds', n, n, ar.CommandFlags.Modal, cc)

 

    # Let's now write a message to the command-line

    doc = aas.Application.DocumentManager.MdiActiveDocument

    ed = doc.Editor

    ed.WriteMessage("\nRegistered Python command: {0}", n)

 

# A simple "Hello World!" command

 

@autocad_command

def msg():

    doc = aas.Application.DocumentManager.MdiActiveDocument

    ed = doc.Editor

    ed.WriteMessage("\nOur test command works!")

 

# And one to do something a little more complex...

# Adds a circle to the current space

 

@autocad_command

def mycir():

 

    doc = aas.Application.DocumentManager.MdiActiveDocument

    db = doc.Database

 

    tr = doc.TransactionManager.StartTransaction()

    bt = tr.GetObject(db.BlockTableId, ads.OpenMode.ForRead)

    btr = tr.GetObject(db.CurrentSpaceId, ads.OpenMode.ForWrite)

 

    cir = ads.Circle(ag.Point3d(10,10,0),ag.Vector3d.ZAxis, 2)

 

    btr.AppendEntity(cir)

    tr.AddNewlyCreatedDBObject(cir, True)

 

    tr.Commit()

    tr.Dispose()

As we’re stuck without the ability to use custom attributes in IronPython, we’re making use of the Autodesk.AutoCAD.Internal namespace to register commands at runtime. I don’t like doing this, but at the same time I was left with little choice, unless we choose to find another way to call into the code. Please be warned that anything contained in the Autodesk.AutoCAD.Internal namespace is unsupported functionality, and subject to change without warning.

Now that I have that off my chest, let’s comment a little further on the above code…

• Even without custom attributes, we have used a pretty cool Python language feature known as decorators (thanks *again* for the tip, Tim :-) which helps us to mark functions as commands. The autocad_command function is called for each decorated function, and this is where we register a command for the function based on the function’s name. Pretty cool.
• You’ll notice a distinct lack of types in the code (and yes, that still scares me). When I was previously trying to compile a DLL based on this code, I had a lot of trouble getting anything at all to fail at compile-time, but clearly a lot would fail at runtime (when I could actually get anything to execute :-S). I feel as though I still need to get my head around this trade-off: I can see the argument for simplicity/elegance/succinctness – and even the power it brings in some situations - but the Computer Scientist in me is screaming for safety/reliability/determinism/debuggability (if that’s even a word). Oh well. The main thing is that I’m starting the journey, at least: we’ll see if it ends up somewhere I like. :-)

When we build and NETLOAD our PythonLoader C# application and execute the PYLOAD command, we can select our Python script:

Command: PYLOAD

Once selected, the script gets loaded and should register a couple of commands:

Registered Python command: msg

Registered Python command: mycir

Running the MSG command will execute a simple “Hello World!”-like function, just printing a message to the command-line:

Command: MSG

Our test command works!

And running the MYCIR command should just add a simple circle to the current space in the active drawing.

Command: MYCIR

That’s it for my initial foray into the world of Python. I hope you’ve found this helpful and enjoy playing around with the Python programming language inside AutoCAD. Please do post a comment if you have experiences or anecdotes to share on this topic!

Tired of not being able to NETUNLOAD from AutoCAD? "Edit and Continue" to the rescue!

A question came in on a previous post:

Hello, I write applications for Autocad Map and Civil3d platforms, mostly with ObjectARX. I would like to do more with .NET but so far the main reason preventing this is not having the NETUNLOAD command.. With arx I can just arxunload and arxload the application for modifications in a second. But with .NET I have to restart the heavy environment and do all kinds of lengthy initializations before being able to try even small changes in code, this can take a minute or more.. Maybe it is possible to create an utility, for development purposes, to unload a .net assembly from Autocad ?

NETUNLOAD has been requested many times by developers, but unfortunately would require a significant change for the .NET API - one it's unclear there'd be significant benefit in making. The root of the situation is that .NET assemblies cannot be unloaded from an AppDomain.

To implement a NETUNLOAD command, we would have to host each assembly in a separate AppDomain and then destroy the AppDomain to unload it. It's altogether possible to implement your own bootstrapper assembly that does just this: I'm going to give that a try, to see how it works, but in the meantime I thought I'd point out (or remind you of) a capability that to greatly reduces the need to continually unload modules from AutoCAD: Visual Studio's Edit and Continue.

Edit and Continue has been around since VB6, although you may not have looked at it in recent versions of Visual Studio. I personally didn't start finding it usable again until Visual Studio 2005 (and its Express Editions). If you'd previously turned your back on it, I suggest taking another look.

To enable Edit and Continue, start by editing the Debugging options (accessed via Tools -> Options in the Visual Studio editor):

If you attempt to edit the code before the module has been loaded, you'll get this error:

And if you try to edit the code before a breakpoint has hit, you'll get this altogether more obscure error:

This message wasn't very helpful - at least not to me. My code wasn't running, as such (although I agree that someone's code was :-) and the setting mentioned was set correctly. Anyway - breaking into your code allows you to then edit the code, which should be obvious by a message on the application status-bar that tells you when the "continue" piece is successful:

I'd be curious to hear about others opinions of Edit and Continue: does it meet your debugging needs, or do you still see NETUNLOAD as important functionality? (There are clearly still areas - unrelated to debugging - where it might be useful to unload .NET assemblies. To be clear, I'd be happy to receive input on those areas, also.)

Loading .NET modules programmatically into AutoCAD

The question of how to perform a "NETLOAD" programmatically has come in a few times. Well, it turns out the answer - provided by someone in our Engineering team - is refreshingly simple.

The NETLOAD command actually has a bare-bones implementation: the hard work of parsing the metadata defining commands etc. is done from an AppDomain.AssemblyLoad event-handler. To recreate the NETLOAD command, all you need to do is call Assembly.LoadFrom(), passing in the path to your assembly.

Here's some C# code to demonstrate this:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using System.Reflection;

namespace LoadModule

{

  public class Commands

  {

    [CommandMethod("MNL")]

    static public void MyNetLoad()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

      PromptStringOptions pso =

        new PromptStringOptions(

          "\nEnter the path of the module to load: "

        );

      pso.AllowSpaces = true;

      PromptResult pr = ed.GetString(pso);

      if (pr.Status != PromptStatus.OK)

        return;

      try

      {

        Assembly.LoadFrom(pr.StringResult);

      }

      catch(System.Exception ex)

      {

        ed.WriteMessage(

          "\nCannot load {0}: {1}",

          pr.StringResult,

          ex.Message

        );

      }

    }

  }

}

Incidentally, my preferred way to manage this is to enable demand loading for your assemblies, as per this previous post. But there are certainly situations where the above technique will prove useful.

In the next post: on Friday you should see the second installment of the interview with John Walker...

More quiet command-calling: adding an inspection dimension inside AutoCAD using .NET

I'm still a little frazzled after transcribing the 18,000 word interview with John Walker (and largely with two fingers - at such times the fact that I've never learned to touch-type is a significant cause of frustration, as you might imagine). I'm also attending meetings all this coming week, so I've gone for the cheap option, once again, of dipping into my magic folder of code generated and provided by my team.

The technique for this one came from a response sent out by Philippe Leefsma, from DevTech EMEA, but he did mention a colleague helped him by suggesting the technique. So thanks to Philippe and our anonymous colleague for the initial idea of calling -DIMINSPECT.

The problem solved by Philippe's code is that no API is exposed via .NET to enable the "inspection" capability of dimensions inside AutoCAD. The protocol is there in ObjectARX, in the AcDbDimension class, but this has - at the time of writing - not been exposed via  the managed API. One option would be to create a wrapper or mixed-mode module to call through to unmanaged C++, but the following approach simply calls through to the -DIMINSPECT command (the command-line version of DIMINSPECT) to set the inspection parameters.

I've integrated - and extended - the technique shown in this previous post to send the command as quietly as possible. One problem I realised with the previous implementation is that UNDO might leave the user in a problematic state - with the NOMUTT variable set to 1. This modified approach does a couple of things differently:

• Rather than using the NOMUTT command to set the system variable, it launches another custom command, FINISH_COMMAND
  • This command has been registered with the NoUndoMarker command-flag, to make it invisible to the undo mechanism (well, at least in terms of automatic undo)
  • It sets the NOMUTT variable to 0
  • It should be possible to share this command across others that have the need to call commands quietly
• It uses the COM API to create an undo group around the operations we want to consider one "command"
• The implementation related to the "quiet command calling" technique is wrapped up in a code region to make it easy to hide

One remaining - and, so far, unavoidable - piece of noise on the command-line is due to our use of the (handent) function: it echoes entity name of the selected dimension.

Here's the C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Interop;

namespace InspectDimension

{

  public class Commands

  {

    [CommandMethod("INSP")]

    static public void InspectDim()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

      PromptEntityOptions peo =

        new PromptEntityOptions("\nSelect a dimension: ");

      peo.SetRejectMessage(

        "\nEntity must be a dimension."

      );

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

      PromptEntityResult per = ed.GetEntity(peo);

      if (per.Status != PromptStatus.OK)

        return;

      Transaction tr =

        db.TransactionManager.StartTransaction();

      using (tr)

      {

        Dimension dim =

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

            as Dimension;

        if (dim != null)

        {

          string shape = "Round";

          string label = "myLabel";

          string rate = "100%";

          string cmd =

            "-DIMINSPECT Add (handent \"" +

            dim.Handle + "\"" + ") \n" +

            shape + "\n" + label + "\n" +

            rate + "\n";

          SendQuietCommand(doc, cmd);

        };

        tr.Commit();

      }

    }

    #region QuietCommandCalling

    const string kFinishCmd = "FINISH_COMMAND";

    private static void SendQuietCommand(

      Document doc,

      string cmd

    )

    {

      // Get the old value of NOMUTT

      object nomutt =

        Application.GetSystemVariable("NOMUTT");

      // Add the string to reset NOMUTT afterwards

      AcadDocument oDoc =

        (AcadDocument)doc.AcadDocument;

      oDoc.StartUndoMark();

      cmd += "_" + kFinishCmd + " ";

      // Set NOMUTT to 1, reducing cmd-line noise

      Application.SetSystemVariable("NOMUTT", 1);

      doc.SendStringToExecute(cmd, true, false, false);

    }

    [CommandMethod(kFinishCmd, CommandFlags.NoUndoMarker)]

    static public void FinishCommand()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      AcadDocument oDoc =

        (AcadDocument)doc.AcadDocument;

      oDoc.EndUndoMark();

      Application.SetSystemVariable("NOMUTT", 0);

    }

    #endregion

  }

}

Here are the results of running the INSP command and selecting a dimension object. First the command-line output:

Command: INSP

Select a dimension: <Entity name: -401f99f0>

Command:

And now the graphics, before and after calling INSP and selecting the dimension:

In the end the post didn't turn out to be quite as quick to write as expected, but anyway - so it goes. I'm now halfway from Zürich to Washington, D.C., and had the time to kill. I probably won't have the luxury when I'm preparing my post for the middle of the week, unless I end up suffering from jet-lag. :-)