Through the Interface

Streamlined QuickSaveAs command for AutoCAD 2010

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

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

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

Here’s the updated C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Windows.ToolPalette;

using System.Runtime.InteropServices;

using System.Drawing;

using System.IO;

using System;

 

namespace QuickSaveAs

{

  public class Commands

  {

    // Set up static variable for the path to our folder

    // of drawings, as well as the base filename and a

    // counter to make the unique filename

 

    static string _path = "",

                  _base = "";

    static int _count = 0;

 

    // Various filename and path-related constants

 

    const string sfxSep = " ",

                pthSep = "\\",

                lspSep = "/",

                dwgExt = ".dwg",

                scrExt = ".txt",

                bmpExt = ".bmp",

                bmpLoc = "Images",

                scrLoc = "Scripts";

 

    // Our QuickSaveAs command

 

    [CommandMethod("QSAVEAS")]

    public void QuickSaveAs()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

      Database db = doc.Database;

 

      // If this is the first time run...

 

      if (_path == "" || _base == "")

      {

        // Ask the user for a base file location

 

        PromptSaveFileOptions opts =

          new PromptSaveFileOptions(

            "Select location to save first drawing file"

          );

        opts.Filter = "Drawing (*.dwg)|*.dwg";

        PromptFileNameResult pr =

          ed.GetFileNameForSave(opts);

 

        if (pr.Status == PromptStatus.OK)

        {

          // If a file was selected, and it contains a path...

 

          // Separate the path from the file name

 

          _base =

            Path.GetFileNameWithoutExtension(pr.StringResult);

          _path =

            Path.GetDirectoryName(pr.StringResult);

 

          // Create folders for our icons and our scripts

 

          Directory.CreateDirectory(

            _path + pthSep + bmpLoc

          );

          Directory.CreateDirectory(

            _path + pthSep + scrLoc

          );

        }

      }

 

      // Assuming the path and name were set appropriately...

 

      if (_path != "" && _base != "")

      {

        string name = _base,

              dwgFile;

 

        // Add our suffix if not the first time run

 

        do

        {

          if (_count > 0)

            name += sfxSep + _count.ToString();

 

          // Our drawing is located in the base path

 

          dwgFile = _path + pthSep + name + dwgExt;

          _count++;

        }

        while (File.Exists(dwgFile));

 

        // While our script is in a sub-folder

 

        string scrPath =

          _path + pthSep + scrLoc + pthSep + name + scrExt;

 

        // Create a dummy script, so we can make sure we pick

        // up the contents in our dummy execute command

 

        File.WriteAllText(

          scrPath,

          "This is a dummy script for " + name + "."

        );

 

        // Now we want to save our drawing and use the image

        // for our tool icon

 

        if (!string.IsNullOrEmpty(dwgFile))

        {

          Bitmap thumb = doc.CapturePreviewImage(320, 240);

          doc.Database.ThumbnailBitmap = thumb;

 

          doc.Database.SaveAs(dwgFile, DwgVersion.Current);

          ed.WriteMessage(

            "\nCopy of current document saved to {0}",

            Path.GetFileName(dwgFile)

          );

 

          CreateCommand(thumb, name, scrPath);

        }

      }

    }

 

    // Function to add a command tool to our tool palette to

    // execute the script

 

    private void CreateCommand(

      Bitmap thumb,

      string name,

      string scrPath

    )

    {

      const string catName = "ScriptCatalog";

      const string palName = "Scripts";

 

      ToolPaletteManager tpm = ToolPaletteManager.Manager;

 

      // Get the GUID of our dummy custom tool

 

      Type t = typeof(DummyTool);

      GuidAttribute ga =

        (GuidAttribute)t.GetCustomAttributes(

          typeof(GuidAttribute), false)[0];

      Guid g = new Guid(ga.Value);

 

      // Instanciate our dummy tool - this will allow us to use

      // its helper functions

 

      DummyTool tool = new DummyTool();

      Catalog cat;

      Palette pal = null;

 

      // First we check whether our GUID is in a catalog

 

      CatalogItem ci = tpm.StockToolCatalogs.Find(g);

      if (ci != null)

      {

        // If it is, search each catalog for our palette

 

        foreach(CatalogItem ci2 in tpm.Catalogs)

        {

          for (int i = 0; i < ci2.ChildCount; i++)

          {

            CatalogItem ci3 = ci2.GetChild(i);

            if (ci3 != null && ci3.Name == palName)

            {

              pal = ci3 as Palette;

              break;

            }

          }

          if (pal != null)

            break;

        }

      }

 

      // If we didn't find our palette, create it

 

      if (pal == null)

      {

        cat = tool.CreateStockTool(catName);

        pal = tool.CreatePalette(cat, palName);

      }

 

      // To add our command tool instance we need an icon

 

      ImageInfo ii = new ImageInfo();

      if (thumb != null)

      {

        // Which we create from the Database's thumbnail

 

        string bmpPath =

          _path + pthSep + bmpLoc + pthSep + name + bmpExt;

        thumb.Save(bmpPath);

        ii.ResourceFile = bmpPath;

      }

      ii.Size = new System.Drawing.Size(65, 65);

 

      // And then we use our dummy tool to create the

      // command tool

 

      tool.CreateCommandTool(

        pal,

        name,

        ii,

        "_EXECSCR \"" + scrPath.Replace(pthSep, lspSep) + "\""

      );

 

      // Finally we reload the catalogs to display the change

 

      tpm.LoadCatalogs(

        CatalogTypeFlags.Catalog,

        LoadFlags.LoadImages

      );

    }

 

    // A dummy command to simulate the execution of our script

    // (which simply reads the contents and displays them on

    // the command-line)

 

    [CommandMethod("EXECSCR")]

    public void ExecuteScript()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

 

      PromptResult pr =

        ed.GetString(

          "\nEnter location of script to execute: "

        );

      if (pr.Status == PromptStatus.OK)

      {

        string path =

          pr.StringResult.Replace(lspSep, pthSep);

        if (File.Exists(path))

        {

          string contents = File.ReadAllText(path);

          ed.WriteMessage(

            "\nDummy script contained: \"{0}\"",

            contents

          );

        }

      }

    }

  }

 

  // Our dummy tool which simply derives from CustomToolBase

  // (there may be a more straightforward way to get access

  // to the helpers in CustomToolBase, but anyway)

 

  [Guid("3B725500-0451-4081-A1BB-B37CE6A65767")]

  [Tool("MyDummyTool", "IDB_TOOL")]

  [ClassInterface(ClassInterfaceType.AutoDual)]

  public class DummyTool : CustomToolBase

  {

  }

}

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

Design iteration #3 of Screenshot, November’s Plugin of the Month

Now that I’m completely finished with my AU 2009 preparation, it’s time for me to get back to the next “Plugin of the Month”, given that we have just a few days left of the month of October.

Here’s another iteration of the application, this time implementing the following enhancements:

• The application now keeps the chosen settings: they follow you between drawings and even between sessions.
• We now perform a Regen after selecting objects to capture to unhighlight them
• There is now a “Print” setting, which gives the option of sending the capture image directly to a printer
  • The image should be scaled to fit the page, all being well
  • I’m not 100% sure I have the algorithm right for the image scaling: feedback is welcome, as ever
• The default location to which captured images are saved if the location of the current drawing
• There’s a slightly longer delay after selecting the file location, to make sure we don’t get dialog artifacts in the capture
• The application should hopefully now support 64-bit versions of AutoCAD (although I’m yet to test this myself)

A huge “thank you” to Bill Woodhams for suggesting most of these changes and testing the results.

Here’s the updated C# code:

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.Windows.Interop;

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; }

      }

    }

 

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

    }

 

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

 

              if (!ad.Clipboard)

                filename = GetFileName(ed);

              ScreenShotToFile(

                Application.DocumentManager.

                  MdiActiveDocument.Window,

                30, 26, 10, 10,

                filename,

                ad

              );

            }

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

            {

              // Capture the entire application window

 

              if (!ad.Clipboard)

                filename = GetFileName(ed);

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

 

              // Regenerate to clear any selection highlighting

 

              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

              );

 

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

              // image

 

              if (!ad.Clipboard)

                filename = GetFileName(ed);

 

              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

 

          if (!ad.Clipboard)

            filename = GetFileName(ed);

 

          ScreenShotToFile(pt1, pt2, filename, 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();

      }

    }

 

    // 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={1}, Foreground={2}, Grayscale={3}",

        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)

    {

      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

        // (300 msec = 3/10ths of a second - may need tweaking)

 

        System.Threading.Thread.Sleep(300);

      }

 

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

        ObjectId vtrId = ObjectId.Null,

                sbId = ObjectId.Null;

 

        bool in3DView = is3D(gsm);

 

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

 

            // 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.Regen();

          }

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

            {

              System.Drawing.Color col;

 

              if (in3DView)

              {

                if (ad.WhiteBackground)

                {

                  col = System.Drawing.Color.White;

                }

                else

                {

                  acedGetCurrentColors(out ocs);

                  uint bgcol = ocs.dwParallelBkColor;

                  col =

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

                }

              }

              else

              {

                bool inModelspace =

                  ((short)Application.GetSystemVariable(

                    "TILEMODE"

                  ) == 0);

                uint bgcol =

                  (inModelspace

                    ? ocs.dwGfxModelBkColor

                    : ocs.dwGfxLayoutBkColor

                  );

                col =

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

              }

              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 (filename != null && filename != "")

              {

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

                ed.WriteMessage(

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

                  filename

                );

              }

 

              // Copy it to the clipboard

 

              if (ad.Clipboard)

              {

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

                ed.WriteMessage(

                  "\nImage 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

          {

            acedSetCurrentColors(ref ocs);

            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 = "MYBACKGROUND";

 

        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

 

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

    }

  }

}

Now if you use the “Print” setting (by changing it to “Yes”) whenever a capture is taken you will be shown a simple print dialog:

This should happen irrespective of whether the image is being saved to a file or copied to the clipboard.

This is almost certainly the final iteration of this tool, so if you have any final feedback, please send it across. And thanks again to all who have contributed, so far, to the design of the tool: I’ve tried to list everyone who has done so in the accompanying ReadMe file to be included in the eventual distribution.

AU 2009: Attend one of my sessions from the comfort of your armchair

Seeing Jeremy's post from Friday, I decided to give you a quick update of where I am with my own preparation for this year’s Autodesk University.

I’m delivering two sessions, this year:

• CP9214-1 AutoCAD® .NET – Developing for AutoCAD Using F#
• CP208-1 AutoCAD® .NET – Developing for AutoCAD Using IronPython and IronRuby

So yes, it seems as though I’m carving out a niche for myself as “the quirky languages guy”. :-)

The first one of these is actually a virtual session, and will be broadcast twice during the week of AU. It’s one I presented already, last year, and here you’ll find both parts of last year’s handouts, although as the F# language has evolved over the last year I’ve had to make some updates that I’ll post, in due course. The good news about it being a virtual session is that you don’t need to travel to Las Vegas to attend the session (I’ll be online from Las Vegas during both the broadcast slots to answer any questions that attendees might have).

The second session I’m presenting is a physical one (in that I’ll be in the same room as the attendees, the only exercise involved will be mental, I assure you :-) and is covering brand new content. During the session we’ll look at the benefits of dynamic programming languages and then focus on integrating IronPython and IronRuby with AutoCAD. We’ll work through a number of samples I’ve posted here, such as jigging solids and turning lines and circles into pipes using the Overrule API in AutoCAD 2010.

For anyone with an interest in broadening their horizons from a programming language perspective (something in which I’m personally a strong believer), I thoroughly recommend signing up for one or other of these classes.

Here is a little more information on AU Virtual:

• Event date: December 1-4, 2009
• 50+ Classes and Sessions streamed “live”
• A “Premium Pass” (full access) is only US$99
• All Subscription customers receive a free “Premier Pass”
• A “Free Pass” (limited access) is available to anyone
• How AU Virtual compares with AU “On-Site”

Adding items to an AutoCAD tool palette using .NET

This post carries directly on from the last one, which implemented a rudimentary “Quick SaveAs” capability in AutoCAD. Much of the explanation behind the design of today’s code is there, so please do read it first (if you haven’t already).

Today we’re taking the code further by automatically creating an item on a tool palette with the thumbnail of the recently-saved drawing which, when used, will run a script created when we saved the drawing.

Here’s the updated code with the new or modified lines in red. You can download the C# source file from here.

    1 using Autodesk.AutoCAD.ApplicationServices;

    2 using Autodesk.AutoCAD.DatabaseServices;

    3 using Autodesk.AutoCAD.EditorInput;

    4 using Autodesk.AutoCAD.Runtime;

    5 using Autodesk.AutoCAD.Windows.ToolPalette;

    6 using System.Runtime.InteropServices;

    7 using System.IO;

    8 using System;

    9 

   10 namespace QuickSaveAs

   11 {

   12   public class Commands

   13   {

   14     // Set up static variable for the path to our folder

   15     // of drawings, as well as the base filename and a

   16     // counter to make the unique filename

   17 

   18     static string _path = "",

   19                   _base = "";

   20     static int _count = 0;

   21 

   22     // Various filename and path-related constants

   23 

   24     const string sfxSep = " ",

   25                 extSep = ".",

   26                 pthSep = "\\",

   27                 lspSep = "/",

   28                 dwgExt = ".dwg",

   29                 scrExt = ".txt",

   30                 bmpExt = ".bmp",

   31                 bmpLoc = "Images",

   32                 scrLoc = "Scripts";

   33 

   34     // Our QuickSaveAs command

   35 

   36     [CommandMethod("QSAVEAS")]

   37     public void QuickSaveAs()

   38     {

   39       Document doc =

   40         Application.DocumentManager.MdiActiveDocument;

   41       Editor ed = doc.Editor;

   42       Database db = doc.Database;

   43 

   44       // If this is the first time run...

   45 

   46       if (_path == "" || _base == "")

   47       {

   48         // Ask the user for a base file location

   49 

   50         PromptSaveFileOptions opts =

   51           new PromptSaveFileOptions(

   52             "Select location to save first drawing file"

   53           );

   54         opts.Filter = "Drawing (*.dwg)|*.dwg";

   55         PromptFileNameResult pr =

   56           ed.GetFileNameForSave(opts);

   57 

   58         // Delete the file, if it exists

   59         // (may be a problem if the file is in use)

   60 

   61         if (File.Exists(pr.StringResult))

   62         {

   63           try

   64           {

   65             File.Delete(pr.StringResult);

   66           }

   67           catch { }

   68         }

   69 

   70         if (pr.Status == PromptStatus.OK)

   71         {

   72           // If a file was selected, and it contains a path...

   73 

   74           if (pr.StringResult.Contains(pthSep))

   75           {

   76             // Separate the path from the file name

   77 

   78             int idx = pr.StringResult.LastIndexOf(pthSep);

   79             _path =

   80               pr.StringResult.Substring(0, idx);

   81             string fullname =

   82               pr.StringResult.Substring(idx+1);

   83 

   84             // If the path has an extension (this should always

   85             // be the case), extract the base file name

   86 

   87             if (fullname.Contains(extSep))

   88             {

   89               _base =

   90                 fullname.Substring(

   91                   0,

   92                   fullname.LastIndexOf(extSep)

   93                 );

   94 

   95               // Create folders for our icons and our scripts

   96 

   97               Directory.CreateDirectory(

   98                 _path + pthSep + bmpLoc

   99               );

  100               Directory.CreateDirectory(

  101                 _path + pthSep + scrLoc

  102               );

  103             }

  104           }

  105         }

  106       }

  107 

  108       // Assuming the path and name were set appropriately...

  109 

  110       if (_path != "" && _base != "")

  111       {

  112         string name = _base;

  113 

  114         // Add our suffix if not the first time run

  115 

  116         if (_count > 0)

  117           name += sfxSep + _count.ToString();

  118 

  119         // Our drawing is located in the base path

  120 

  121         string dwgPath = _path + pthSep + name + dwgExt;

  122 

  123         // While our script is in a sub-folder

  124 

  125         string scrPath =

  126           _path + pthSep + scrLoc + pthSep + name + scrExt;

  127 

  128         // Create a dummy script, so we can make sure we pick

  129         // up the contents in our dummy execute command

  130 

  131         File.WriteAllText(

  132           scrPath,

  133           "This is a dummy script for " + name + "."

  134         );

  135 

  136         // Now we want to save our drawing and use the image

  137         // for our tool icon

  138 

  139         // Using either COM or .NET doesn't generate a

  140         // thumbnail in the resultant file (or its Database)

  141 

  142         // .NET:

  143         // db.SaveAs(dwgPath, false, DwgVersion.Current, null);

  144 

  145         // COM:

  146         // AcadDocument adoc = (AcadDocument)doc.AcadDocument;

  147         // adoc.SaveAs(dwgPath, AcSaveAsType.acNative, null);

  148 

  149         // So we'll send commands to the command-line

  150         // We'll use LISP, to avoid having to set FILEDIA to 0

  151 

  152         object ocmd = Application.GetSystemVariable("CMDECHO");

  153         string dwgPath2 = dwgPath.Replace(pthSep, lspSep);

  154         string scrPath2 = scrPath.Replace(pthSep, lspSep);

  155 

  156         string c1 =

  157           "(setvar \"CMDECHO\" 0)" +

  158           "(command \"_.SAVEAS\" \"\" \"" + dwgPath2 + "\")";

  159         string c2 =

  160           "(setvar \"CMDECHO\" " + ocmd.ToString() + ")" +

  161           "(tp-create \"" + name + "\" \"" + scrPath2 + "\")" +

  162           "(princ) ";

  163         string cmd = c1 + c2;

  164 

  165         if (cmd.Length <= 255)

  166         {

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

  168         }

  169         else

  170         {

  171           doc.SendStringToExecute(c1+" ", false, false, false);

  172           doc.SendStringToExecute(c2, false, false, false);

  173         }

  174 

  175         // Print a confirmation message for the DWG save

  176         // (which actually gets displayed before the queued

  177         // string gets executed, but anyway)

  178 

  179         ed.WriteMessage("\nSaved to: \"" + dwgPath + "\"");

  180 

  181         _count++;

  182       }

  183     }

  184 

  185     // Our LISP-registered continuation function to create a

  186     // command tool on our tool palette

  187 

  188     [LispFunction("TP-CREATE")]

  189     public ResultBuffer CreateToolPaletteCommand(

  190       ResultBuffer rb

  191     )

  192     {

  193       const int RTSTR = 5005;

  194 

  195       Document doc =

  196         Application.DocumentManager.MdiActiveDocument;

  197       Editor ed = doc.Editor;

  198 

  199       if (rb == null)

  200       {

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

  202       }

  203       else

  204       {

  205         // We're only interested in the first two arguments

  206 

  207         Array args = rb.AsArray();

  208         if (args.Length != 2)

  209         {

  210           ed.WriteMessage(

  211             "\nError: wrong number of arguments."

  212           );

  213         }

  214         else

  215         {

  216           // First argument is the name, second is the path

  217           // to the script

  218 

  219           TypedValue tv1 = (TypedValue)args.GetValue(0);

  220           TypedValue tv2 = (TypedValue)args.GetValue(1);

  221 

  222           if (tv1 != null && tv1.TypeCode == RTSTR &&

  223               tv2 != null && tv2.TypeCode == RTSTR)

  224           {

  225             string name = Convert.ToString(tv1.Value);

  226             string lspScrPath = Convert.ToString(tv2.Value);

  227             string scrPath =

  228               lspScrPath.Replace(lspSep, pthSep);

  229             bool success =

  230               CreateCommand(doc.Database, name, scrPath);

  231             return

  232               (success ?

  233                 new ResultBuffer(

  234                   new TypedValue(RTSTR, tv1.Value)

  235                 )

  236                 : null);

  237           }

  238         }

  239       }

  240       return null;

  241     }

  242 

  243     // Function to add a command tool to our tool palette to

  244     // execute the script

  245 

  246     private bool CreateCommand(

  247       Database db,

  248       string name,

  249       string scrPath

  250     )

  251     {

  252       const string catName = "ScriptCatalog";

  253       const string palName = "Scripts";

  254 

  255       ToolPaletteManager tpm = ToolPaletteManager.Manager;

  256 

  257       // Get the GUID of our dummy custom tool

  258 

  259       Type t = typeof(DummyTool);

  260       GuidAttribute ga =

  261         (GuidAttribute)t.GetCustomAttributes(

  262           typeof(GuidAttribute), false)[0];

  263       Guid g = new Guid(ga.Value);

  264 

  265       // Instanciate our dummy tool - this will allow us to use

  266       // its helper functions

  267 

  268       DummyTool tool = new DummyTool();

  269       Catalog cat;

  270       Palette pal = null;

  271 

  272       // First we check whether our GUID is in a catalog

  273 

  274       CatalogItem ci = tpm.StockToolCatalogs.Find(g);

  275       if (ci != null)

  276       {

  277         // If it is, search each catalog for our palette

  278 

  279         foreach(CatalogItem ci2 in tpm.Catalogs)

  280         {

  281           for (int i = 0; i < ci2.ChildCount; i++)

  282           {

  283             CatalogItem ci3 = ci2.GetChild(i);

  284             if (ci3 != null && ci3.Name == palName)

  285             {

  286               pal = ci3 as Palette;

  287               break;

  288             }

  289           }

  290           if (pal != null)

  291             break;

  292         }

  293       }

  294 

  295       // If we didn't find our palette, create it

  296 

  297       if (pal == null)

  298       {

  299         cat = tool.CreateStockTool(catName);

  300         pal = tool.CreatePalette(cat, palName);

  301       }

  302 

  303       // To add our command tool instance we need an icon

  304 

  305       ImageInfo ii = new ImageInfo();

  306       if (db.ThumbnailBitmap != null)

  307       {

  308         // Which we create from the Database's thumbnail

  309 

  310         string bmpPath =

  311           _path + pthSep + bmpLoc + pthSep + name + bmpExt;

  312         db.ThumbnailBitmap.Save(bmpPath);

  313         ii.ResourceFile = bmpPath;

  314       }

  315       ii.Size = new System.Drawing.Size(65, 65);

  316 

  317       // And then we use our dummy tool to create the

  318       // command tool

  319 

  320       tool.CreateCommandTool(

  321         pal,

  322         name,

  323         ii,

  324         "_EXECSCR \"" + scrPath.Replace(pthSep, lspSep) + "\""

  325       );

  326 

  327       // Finally we reload the catalogs to display the change

  328 

  329       tpm.LoadCatalogs();

  330 

  331       return true;

  332     }

  333 

  334     // A dummy command to simulate the execution of our script

  335     // (which simply reads the contents and displays them on

  336     // the command-line)

  337 

  338     [CommandMethod("EXECSCR")]

  339     public void ExecuteScript()

  340     {

  341       Document doc =

  342         Application.DocumentManager.MdiActiveDocument;

  343       Editor ed = doc.Editor;

  344 

  345       PromptResult pr =

  346         ed.GetString(

  347           "\nEnter location of script to execute: "

  348         );

  349       if (pr.Status == PromptStatus.OK)

  350       {

  351         string path =

  352           pr.StringResult.Replace(lspSep, pthSep);

  353         if (File.Exists(path))

  354         {

  355           string contents = File.ReadAllText(path);

  356           ed.WriteMessage(

  357             "\nDummy script contained: \"{0}\"",

  358             contents

  359           );

  360         }

  361       }

  362     }

  363   }

  364 

  365   // Our dummy tool which simply derives from CustomToolBase

  366   // (there may be a more straightforward way to get access

  367   // to the helpers in CustomToolBase, but anyway)

  368 

  369   [Guid("3B725500-0451-4081-A1BB-B37CE6A65767")]

  370   [Tool("MyDummyTool", "IDB_TOOL")]

  371   [ClassInterface(ClassInterfaceType.AutoDual)]

  372   public class DummyTool : CustomToolBase

  373   {

  374   }

  375 }

Some notes on the changes:

• Lines 5, 6 and 8 add some additional namespaces.
  • It's worth noting that you'll need to add an assembly reference to AcTcMgd (depending on the version of AutoCAD you're using), for the updated code to build.
• Lines 28-32 add some additional constants related to scripts and icon images.
• Lines 95-102 create additional directories for our scripts and images.
• Lines 123-134 create a dummy script when we save a drawing.
• Lines 154-173 deal with a limitation we have with sending strings to the command-line:
  • AutoCAD’s command-line input buffer is only 255 characters in size, so if our string is longer (because of a deep file path), we send it in two pieces, terminating the first with a space character. It’s still possible that really deep paths could cause a problem with this code, but splitting the string further is left as an exercise for the reader. :-)
  • The string also calls a new continuation function (registered via LISP, see below) to create an item on our tool palette.
• Lines 185-241 register a continuation function via LISP, so we can get control back in our code once the SAVEAS command has completed.
• Lines 243-332 define a function to create an item on our tool palette. This function is called from the above LISP function.
• Lines 334-363 simulate the execution of a script, so that when our tool palette is used, something happens.
  • The command simply reads in the contents of the "script" file and prints the contents to the command-line.
• Lines 365-374 define a dummy custom tool, which we use as a shortcut for certain tool palette-related operations.

Now let’s take a look at the results of running this. In the last post we saw an example where a number of drawings get created in a particular folder. If we perform the same operations with this code, the same things happen (no need to show the drawings or the command-line output, they should be the same), but in addition we see a tool palette populated with images of our model at various stages:

You may have to right-click the stacked tool palette tabs to locate the “Scripts” tool palette (I haven’t found a way of doing this automatically, as it wasn’t really essential for my particular application).

When we select the items on the tool palette in sequence, we see our EXECSCR command is called with the location of the script created for each DWG file, which then gets read and printed to the command-line:

Command: _EXECSCR

Enter location of script to execute:

"C:/QSaveAs Test/Scripts/Solid model.txt"

Dummy script contained: "This is a dummy script for Solid model."

Command: _EXECSCR

Enter location of script to execute:

"C:/QSaveAs Test/Scripts/Solid model 1.txt"

Dummy script contained: "This is a dummy script for Solid model 1."

Command: _EXECSCR

Enter location of script to execute:

"C:/QSaveAs Test/Scripts/Solid model 2.txt"

Dummy script contained: "This is a dummy script for Solid model 2."

Command: _EXECSCR

Enter location of script to execute:

"C:/QSaveAs Test/Scripts/Solid model 3.txt"

Dummy script contained: "This is a dummy script for Solid model 3."

Command: _EXECSCR

Enter location of script to execute:

"C:/QSaveAs Test/Scripts/Solid model 4.txt"

Dummy script contained: "This is a dummy script for Solid model 4."

Command: _EXECSCR

Enter location of script to execute:

"C:/QSaveAs Test/Scripts/Solid model 5.txt"

Dummy script contained: "This is a dummy script for Solid model 5."

While clearly not actually doing anything useful, the script file that we’ve created (and I don’t mean script in the AutoCAD sense of the term – I’m using it in a more generic sense) could actually be regenerating the drawing contents (for instance). With a little more work. :-)

Update:

This post shows a streamlined approach for this application for AutoCAD 2010 and above.

Implementing a “Quick SaveAs” command in AutoCAD using .NET

I had a fun request, earlier in the week, that I thought worth turning into a couple of blog posts. The problem itself is quite specific, but some of the techniques shown – especially in the second of the two posts – seemed worth sharing.

The basic request was this: to implement a “quick SaveAs” command which will – the first time it’s run – ask for a file location and name and will then – each time it’s called subsequently – simply save the current drawing into the same folder with a filename based on the original with a incrementing suffix.

An example: the first time you run QSAVEAS you get presented with a SaveAs dialog and choose “c:\temp\Test.dwg”. Each time you call QSAVEAS afterwards a new drawing gets created in the temp folder: “Test 1.dwg”, “Test 2.dwg”, “Test 3.dwg”, etc.

This is likely to be a handy technique for people who want to take regular snapshots of their designs as they’re working.

There’s another dimension to this particular problem, however, which is why we’re looking at it over the course of two posts: imagine we’re in an environment where some kind of script or external data-file is being generated automatically for later recreation of the model. You can think of the mechanism as being a little like AutoCAD’s action recorder, although this is not about capturing user operations as much as it is about storing the information needed to recreate at a later point in time the model being worked upon.

We still want to save our DWG file – as this is a “snapshot” of the model that we can use in other systems taking AutoCAD drawings as inputs – but we also want to save our script/data-file, which is really the file that will be used to recreate the model. And at the same time we want to create an item on a special tool palette which will call a command to execute our script (or interpret our data-file). And this command tool needs to have the icon of the drawing we’ve just saved. Fun stuff! :-)

Anyway, before we get too carried away on the tool palette manipulation code – which will come in the next post – we’re going to look at our simple QSAVEAS command. I did want to set the stage appropriately, though, as the need to save the DWG and have its thumbnail preview available has driven some implementation decisions in today’s code.

One thing I should add, quickly: I’m not going to look at how we recreate our model from the script/data-file. That is really a much bigger problem and beyond the scope of these posts, which focus more on defining the QSAVEAS command and the steps needed to populate our tool palette. In the next post we will create a dummy script, but only to show how this can be picked up when our tool palette is used.

Here’s the C# code implementing our QSAVEAS command:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using System.IO;

 

namespace QuickSaveAs

{

  public class Commands

  {

    // Set up static variable for the path to our folder

    // of drawings, as well as the base filename and a

    // counter to make the unique filename

 

    static string _path = "",

                  _base = "";

    static int _count = 0;

 

    // Various filename and path-related constants

 

    const string sfxSep = " ",

                extSep = ".",

                pthSep = "\\",

                lspSep = "/",

                dwgExt = ".dwg";

 

    // Our QuickSaveAs command

 

    [CommandMethod("QSAVEAS")]

    public void QuickSaveAs()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

      Database db = doc.Database;

 

      // If this is the first time run...

 

      if (_path == "" || _base == "")

      {

        // Ask the user for a base file location

 

        PromptSaveFileOptions opts =

          new PromptSaveFileOptions(

            "Select location to save first drawing file"

          );

        opts.Filter = "Drawing (*.dwg)|*.dwg";

        PromptFileNameResult pr =

          ed.GetFileNameForSave(opts);

 

        // Delete the file, if it exists

        // (may be a problem if the file is in use)

 

        if (File.Exists(pr.StringResult))

        {

          try

          {

            File.Delete(pr.StringResult);

          }

          catch { }

        }

 

        if (pr.Status == PromptStatus.OK)

        {

          // If a file was selected, and it contains a path...

 

          if (pr.StringResult.Contains(pthSep))

          {

            // Separate the path from the file name

 

            int idx = pr.StringResult.LastIndexOf(pthSep);

            _path =

              pr.StringResult.Substring(0, idx);

            string fullname =

              pr.StringResult.Substring(idx + 1);

 

            // If the path has an extension (this should always

            // be the case), extract the base file name

 

            if (fullname.Contains(extSep))

            {

              _base =

                fullname.Substring(

                  0,

                  fullname.LastIndexOf(extSep)

                );

            }

          }

        }

      }

 

      // Assuming the path and name were set appropriately...

 

      if (_path != "" && _base != "")

      {

        string name = _base;

 

        // Add our suffix if not the first time run

 

        if (_count > 0)

          name += sfxSep + _count.ToString();

 

        // Our drawing is located in the base path

 

        string dwgPath = _path + pthSep + name + dwgExt;

 

        // Now we want to save our drawing and use the image

        // for our tool icon

 

        // Using either COM or .NET doesn't generate a

        // thumbnail in the resultant file (or its Database)

 

        // .NET:

        // db.SaveAs(dwgPath, false, DwgVersion.Current, null);

 

        // COM:

        // AcadDocument adoc = (AcadDocument)doc.AcadDocument;

        // adoc.SaveAs(dwgPath, AcSaveAsType.acNative, null);

 

        // So we'll send commands to the command-line

        // We'll use LISP, to avoid having to set FILEDIA to 0

 

        object ocmd = Application.GetSystemVariable("CMDECHO");

        string dwgPath2 = dwgPath.Replace(pthSep, lspSep);

 

        doc.SendStringToExecute(

          "(setvar \"CMDECHO\" 0)" +

          "(command \"_.SAVEAS\" \"\" \"" + dwgPath2 + "\")" +

          "(setvar \"CMDECHO\" " + ocmd.ToString() + ")" +

          "(princ) ",

          false,

          false,

          false

        );

 

        // Print a confirmation message for the DWG save

        // (which actually gets displayed before the queued

        // string gets executed, but anyway)

 

        ed.WriteMessage("\nSaved to: \"" + dwgPath + "\"");

 

        _count++;

      }

    }

  }

}

A few further comments on the implementation:

There are various ways to save a DWG file from .NET, but the requirement to have a thumbnail preview image created with the file (which is then accessible from its editor-resident Database) has limited our choice somewhat: neither Database.SaveAs() nor AcadDocument.SaveAs() (the .NET and COM methods) generate and save a thumbnail.

So we’re calling the SAVEAS command, which does generate the thumbnail. We could call this in a number of ways - COM’s AcadDocument.SendCommand() would call SAVEAS synchronously, for instance – but I’ve decided to use Document.SendStringToExecute() to fire off our SAVEAS and (eventually) launch a continuation function to update the tool palette.

We’re setting CMDECHO to keep the noise down on the command-line, but we’ve managed to avoid having to set FILEDIA to zero by wrapping the call in a LISP (command) call (which AutoCAD knows prefers command-line input).

Here’s what happens when we run the QSAVEAS command at regular intervals during an editing session:

Command: NETLOAD

Command: QSAVEAS

[Selected initial location via file selection dialog...]

Saved to: "C:\QSaveAs Test\Solid model.dwg"

[Various editing operations...]

Command: QSAVEAS

Saved to: "C:\QSaveAs Test\Solid model 1.dwg"

[Various editing operations...]

Command: QSAVEAS

Saved to: "C:\QSaveAs Test\Solid model 2.dwg"

[Various editing operations...]

Command: QSAVEAS

Saved to: "C:\QSaveAs Test\Solid model 3.dwg"

[Various editing operations...]

Command: QSAVEAS

Saved to: "C:\QSaveAs Test\Solid model 4.dwg"

[Various editing operations...]

Command: QSAVEAS

Saved to: "C:\QSaveAs Test\Solid model 5.dwg"

And here are the files, shown in Explorer:

Update:

This post shows a streamlined approach for this application for AutoCAD 2010 and above.

Free webcast on AutoCAD VBA to .NET Migration

Sorry for the late notice on this one… I’d have posted sooner but for having taken some time off, last week, to take the family to Disneyland Paris. Now I just need a few more days of vacation to recover. :-S :-)

Tomorrow there’s a free webcast showing how to migrate your VBA code to use VBA.NET. The content focuses primarily on the use of COM Interop to quickly get your VBA code working from VB.NET, building on the DevTV session mentioned previously and using its accompanying migration tool.

The session will be taking place at 8am Pacific/10am Eastern/4pm in the UK/5pm in Central Europe, on October 20, 2009.

To register, please go to our API training schedule (also accessible via http://www.autodesk.com/apitraining). As usual, we will be posting links to the recording of this session on the API training schedule page, in case you’re not able to attend at such short notice.

Design iteration #2 of Screenshot, November’s Plugin of the Month

Thanks to all those who provided feedback on this recent post. I really appreciate people taking the time to provide feedback – both positive and negative – as I want to ensure this tool is used by more than just a few AutoCAD users. Today’s version extends the last one to include a few more “Settings”:

• Existing settings
  • Output
    • Allows the user to choose whether the captured image is copied to the clipboard or saved to a raster file
  • Background
    • Allows the user to force the background colour to white
      • Hopefully useful for people using a non-quite background but want to create images for documentation
• New settings
  • Foreground
    • Allows the user to force the foreground colour (and that means everything not the same colour as the background, at least for now) to black
      • This can be used in combination with “Background” to create a pure black & white image
  • Grayscale
    • Allows the user to force the resultant image to be grayscale (can be used in conjunction with Foreground and/or Background, but may therefore not have any visible effects)

At Mark Johnston’s suggestion (and thanks for your help with testing these options, Mark!) I also added a message to indicate when the capture has occurred (and where the resultant image has been placed). And thanks to Viru Aithal, our DevTech India Manager, for providing some code to change the background colour of a 3D view.

In terms of future enhancements… I’m chewing on an option to hide the navigations aids (e.g. the UCS Icon and the ViewCube). Visibility of the UCS Icon should be simple enough to control via the active viewport, but disabling the ViewCube is likely to be more complex: I haven’t yet seen a .NET equivalent for the acdbGetShowCompass() ObjectARX function – P/Invoking it is possible, I expect – and the other option would involve calling the NAVVCUBE command, but as it needs to run synchronously I’d have to use SendCommand() via COM. Either approach adds complexity and/or version dependency issues, so I’m starting to veer away from this direction. Please do post any thoughts you might have as comments, of course.

Here’s the updated C# code:

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;

using System.Runtime.InteropServices;

using System.Windows.Interop;

using System.Collections;

using System;

 

namespace ScreenshotTest

{

  public class Commands

  {

    // Specify a key under which we want

    //  to store our custom data

 

    const string myKey = "AdnPluginScreenshot";

 

    // Define a class for our custom data

 

    public class AppData

    {

      public bool clipboard;

      public bool whitebackground;

      public bool blackforeground;

      public bool grayscale;

 

      public AppData()

      {

        clipboard = true;

        whitebackground = false;

        blackforeground = false;

        grayscale = false;

      }

    }

 

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

      out AcColorSettings colorSettings

    );

 

    [DllImport("acad.exe",

    CallingConvention=CallingConvention.Cdecl,

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

    )]

    static extern bool acedSetCurrentColors(

      ref AcColorSettings colorSettings

    );

 

    // 64-bit versions of these functions, for when we support that

 

    [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

    );

 

    // Command to capture the main and active drawing windows

    // or a user-selected portion of a drawing

 

    [CommandMethod("SCREENSHOT")]

    static public void CaptureScreenShot()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

 

      Hashtable ud = doc.UserData;

      AppData ad;

 

      ad = ud[myKey] as AppData;

      if (ad == null)

      {

        object obj = ud[myKey];

        if (obj == null)

        {

          // MyData object not found - first time run

 

          ad = new AppData();

          ud.Add(myKey, ad);

        }

        else

        {

          // Found something different instead

 

          ed.WriteMessage(

            "Found an object of type \"" +

            obj.GetType().ToString() +

            "\" instead of MyData.");

        }

      }

 

      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

 

              if (!ad.clipboard)

                filename = GetFileName(ed);

              ScreenShotToFile(

                Application.DocumentManager.

                  MdiActiveDocument.Window,

                30, 26, 10, 10,

                filename,

                ad

              );

            }

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

            {

              // Capture the entire application window

 

              if (!ad.clipboard)

                filename = GetFileName(ed);

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

 

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

              );

 

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

              // image

 

              if (!ad.clipboard)

                filename = GetFileName(ed);

 

              ScreenShotToFile(pt1, pt2, filename, ad);

            }

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

            {

              if (GetSettings(ed, ad))

                ud[myKey] = ad;

              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

 

          if (!ad.clipboard)

            filename = GetFileName(ed);

 

          ScreenShotToFile(pt1, pt2, filename, 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();

      }

    }

 

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

 

    private static void PrintSettings(Editor ed, AppData ad)

    {

      ed.WriteMessage(

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

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

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

        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/Background/Foreground/Grayscale/Exit]: ",

          "Output 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 == "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)

    {

      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";

 

      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

        // (100 msec = 1/10th of a second - may need tweaking)

 

        System.Threading.Thread.Sleep(100);

      }

 

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

        ObjectId vtrId = ObjectId.Null,

                sbId = ObjectId.Null;

 

        bool in3DView = is3D(gsm);

 

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

 

            // 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.Regen();

          }

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

            {

              System.Drawing.Color col;

 

              if (in3DView)

              {

                if (ad.whitebackground)

                {

                  col = System.Drawing.Color.White;

                }

                else

                {

                  acedGetCurrentColors(out ocs);

                  uint bgcol = ocs.dwParallelBkColor;

                  col =

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

                }

              }

              else

              {

                bool inModelspace =

                  ((short)Application.GetSystemVariable(

                    "TILEMODE"

                  ) == 0);

                uint bgcol =

                  (inModelspace

                    ? ocs.dwGfxModelBkColor

                    : ocs.dwGfxLayoutBkColor

                  );

                col =

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

              }

              processed =

                ConvertToGrayscale(

                  bmp,

                  col,

                  ad.blackforeground,

                  System.Drawing.Color.Black

                );

            }

            else

            {

              processed = bmp;

            }

            // Save the screenshot to the specified location

 

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

            {

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

              ed.WriteMessage(

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

                filename

              );

            }

 

            // Copy it to the clipboard

 

            if (ad.clipboard)

            {

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

              ed.WriteMessage(

                "\nImage captured to the clipboard."

              );

            }

          }

        }

        if (ad.whitebackground)

        {

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

          {

            Remove3DBackground(db, tr, vtrId, sbId);

          }

          else

          {

            acedSetCurrentColors(ref ocs);

            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 = "MYBACKGROUND";

 

        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

 

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

    }

  }

}

Here are the results of running SCREENSHOT with various options, starting with a black drawing background (which is quite common-place):

 

Background = Normal

Foreground = Normal

Grayscale = Off

 

 

 

Background = ForceToWhite

Foreground = Normal

Grayscale = Off

 

 

Background = ForceToWhite

Foreground = ForceToBlack

Grayscale = On/Off

 

 

Background = ForceToWhite

Foreground = Normal

Grayscale = On

 

 

Background = Normal

Foreground = Normal

Grayscale = On

 

 

Background = Normal

Foreground = ForceToBlack

Grayscale = On/Off

 

 

The last one is clearly less than useful, but it’s there for completeness. :-)

Just to show it works, here are a few images taken in a 3D view (shown in the same sequence as the above 2D images):

The clipping of the 3D window when using the “Document” option seems slightly different in 3D (as you can see from the additional line at the bottom of the screen), which is something I’ll address, at some point.

Anyway, please do keep the feedback coming (although as I’m on vacation – and away from a PC - for the rest of the week you may not see me respond until next week).

Free AutoCAD API webcast: 0 to 3D in 60 Minutes

Next week Fenton Webb, from DevTech Americas, will be presenting a free webcast on the 3D capabilities of AutoCAD’s APIs. Here’s Fenton’s synopsis:

“If your product has always been 2D and you are now considering moving to 3D or if you are simply interested in finding out about the different API’s that are available to program AutoCAD in 3D then come join this webcast. We’ll give a brief overview history of 3D in AutoCAD along with some code demonstrations of some API’s in operation. Also, don’t forget that included at the end is a Q and A section allowing you to ask any questions you might have.”

The session will be taking place at 8am Pacific/10am Eastern/4pm in the UK/5pm in Central Europe, on October 13, 2009, and will presumably last about an hour (although I can well imagine the Q&A might make it longer). :-)

To register, please go to our API training schedule (also accessible via http://www.autodesk.com/apitraining). As usual, we will be posting links to the recording of this session on the API training schedule page, in case you’re not able to attend.

Design iteration #1 of Screenshot, November’s Plugin of the Month

Thanks to all who provided input on this last post, where I asked for guidance on how best to design the command-line interface for the Screenshot application, the proposed Plugin of the Month for November. The current code is based largely on this previous post, but may end up being extended - in time - to include better 3D support via the technique shown here.

Here are some design choices that came out of the comments on the last post:

• From Fred Dickinson
  • A separate “Settings” option, allowing us to use a sub-menu for our application settings
• From MJohnston
  • Display of the last used options when the command launches
  • The option to change the background colour to white for the capture
• From Mark Dubbelaar
  • Some nice design choices around command and options naming, as well as settings placement
  • The option to select a group of objects for which to capture the extents

And an honourable mention goes to Chris Bray, Nikolay Poleschuk and James Meading, who made additional suggestions and suggested possible future directions. Thanks, all of you! So far so good with this crowdsourcing experiment. :-)

Here’s the current state of the C# code, reflecting the above input as best I could:

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 System.Drawing.Imaging;

using System.Drawing;

using System.Runtime.InteropServices;

using System.Windows.Interop;

using System.Collections;

using System;

 

namespace ScreenshotTest

{

  public class Commands

  {

    // Specify a key under which we want

    //  to store our custom data

 

    const string myKey = "AdnPluginScreenshot";

 

    // Define a class for our custom data

 

    public class AppData

    {

      public bool clipboard;

      public bool whitebackground;

      public AppData()

      {

        clipboard = true;

        whitebackground = false;

      }

    }

 

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

    /*

    Here's the x64 version of the EntryPoint:

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

      */

    )]

    static extern bool acedGetCurrentColors(

      out AcColorSettings colorSettings

    );

 

    [DllImport("acad.exe",

    CallingConvention=CallingConvention.Cdecl,

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

    /*

    Here's the x64 version of the EntryPoint:

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

      */

    )]

    static extern bool acedSetCurrentColors(

      ref AcColorSettings colorSettings

    );

 

    // Command to capture the main and active drawing windows

    // or a user-selected portion of a drawing

 

    [CommandMethod("SCREENSHOT")]

    static public void CaptureScreenShot()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

 

      Hashtable ud = doc.UserData;

      AppData ad;

 

      ad = ud[myKey] as AppData;

      if (ad == null)

      {

        object obj = ud[myKey];

        if (obj == null)

        {

          // MyData object not found - first time run

 

          ad = new AppData();

          ud.Add(myKey, ad);

        }

        else

        {

          // Found something different instead

 

          ed.WriteMessage(

            "Found an object of type \"" +

            obj.GetType().ToString() +

            "\" instead of MyData.");

        }

      }

 

      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

 

              if (!ad.clipboard)

                filename = GetFileName(ed);

              ScreenShotToFile(

                Application.DocumentManager.

                  MdiActiveDocument.Window,

                30, 26, 10, 10,

                filename,

                ad

              );

            }

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

            {

              // Capture the entire application window

 

              if (!ad.clipboard)

                filename = GetFileName(ed);

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

 

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

              );

 

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

              // image

 

              if (!ad.clipboard)

                filename = GetFileName(ed);

 

              ScreenShotToFile(pt1, pt2, filename, ad);

            }

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

            {

              if (GetSettings(ed, ad))

                ud[myKey] = ad;

              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

 

          if (!ad.clipboard)

            filename = GetFileName(ed);

 

          ScreenShotToFile(pt1, pt2, filename, 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();

      }

    }

 

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

 

    private static void PrintSettings(Editor ed, AppData ad)

    {

      ed.WriteMessage(

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

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

        ad.whitebackground ? "ForceToWhite" : "Normal"

      );

    }

 

    // 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/Background/Exit]: ",

          "Output Background Exit"

        );

      pko.Keywords.Default = "Exit";

 

      PromptResult pr;

      bool changed = 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;

                changed = true;

              }

            }

          }

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

          {

            // If Background is chosen, ask whether to

            // force the background colour to white

            // (we could allow selection of a colour,

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

 

            PromptKeywordOptions pko3 =

              new PromptKeywordOptions(

                "\nForce background color to white " +

                "[Yes/No]: ",

                "Yes No"

              );

 

            // The default depends on our current settings

 

            pko3.Keywords.Default =

              (ad.whitebackground ? "Yes" : "No");

            PromptResult pr3 = ed.GetKeywords(pko3);

 

            if (pr3.Status == PromptStatus.OK)

            {

              // Change the settings, as needed

 

              bool whitebackground =

                (pr3.StringResult == "Yes");

 

              if (ad.whitebackground != whitebackground)

              {

                ad.whitebackground = whitebackground;

                changed = true;

              }

            }

          }

        }

      }

      while(

        pr.Status == PromptStatus.OK &&

        pr.StringResult != "Exit"

      );  // Loop until Exit or cancel

 

      return changed;

    }

 

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

 

    private static string GetFileName(Editor ed)

    {

      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";

 

      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

        // (100 msec = 1/10th of a second - may need tweaking)

 

        System.Threading.Thread.Sleep(100);

      }

 

      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;

 

      AcColorSettings ocs = new AcColorSettings();

      if (ad.whitebackground)

      {

        // Get the current system colours

 

        acedGetCurrentColors(out ocs);

 

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

 

        // Update the screen to reflect the changes

 

        ed.Regen();

        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

          );

 

          // Save the screenshot to the specified location

 

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

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

 

          // Copy it to the clipboard

 

          if (ad.clipboard)

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

        }

      }

      if (ad.whitebackground)

      {

        acedSetCurrentColors(ref ocs);

 

        ed.Regen();

        ed.UpdateScreen();

      }

    }

 

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

    }

  }

}

Some notes on some of the additional features this code introduces…

To temporarily change the background colour to white I’ve resorted to P/Invoking a couple of ObjectARX functions, acedGetCurrentColors() and acedSetCurrentColors(), as these give direct access to AutoCAD’s colour scheme and allow it to be changed on the spot (with the exception of the 3D drawing background – changing this currently doesn’t have any immediate impact on AutoCAD, and I haven’t yet found a way to force AutoCAD to pick up the colour change). The problem with using P/Invoke on functions with decorated names is that the signatures tend to differ between 32- and 64-bit systems (and may also have changed at other times, although the last time this impacted a lot of functions was during the Unicode migration between AutoCAD 2006 and 2007, and mostly affected functions passing strings). I’ve included the modified EntryPoint values for 64-bit systems as comments – these will either become conditional compilation statements, in time, or even something more dynamic (if I can find a way to create DllImport attributes dynamically at runtime). [Thanks to Augusto Gonçalves, from DevTech Americas, for writing the code I plundered to get these two functions working properly.]

I’ve added a small delay after asking the user for a filename: in the case that you need to overwrite a file, the dialogs may not be dismissed quickly enough (at least not when using aero on Vista :-). Here’s a sample capture showing the issue when we don’t have the delay:

To enable capture of the extents defined by a set of objects selected by the user, I’ve added a function called GetExtentsOfSelection() which returns two screen points defining the approximate extents of the various objects. I say approximate, because we’re taking the geometric (WCS) extents of the objects, converting the minimum and maximum values (the coordinates defining the lower-left and upper-right corners) into screen coordinates, and then using the smallest and largest X and Y values to create our new screen capture window. Which is far from perfect: the geometric extents may very well not define the screen extents. To make this more reliable, we could probably take more sampling points on the objects and check those against our extents once converted into screen coordinates. But that seems like a lot of effort – especially as users can always select capture windows themselves – so this is left as an exercise for the obsessive-compulsive reader. (On a side note, my wife often teases me for having borderline obsessive-compulsive tendencies, although she clearly wishes some of them would lead to us having a cleaner, tidier home. :-)

Anyway – that’s pretty much it in terms of the implementation, thus far.

To get a feel for the command-line prompts, here’s the code in action, with the user-inputs in red:

Command: SCREENSHOT

Current settings: Output=Clipboard, Background=Normal

Select first point of capture window or [Document/Application/Objects/Settings]: S

Current settings: Output=Clipboard, Background=Normal

Setting to change [Output/Background/Exit] <Exit>: O

Save to file or place on the clipboard [File/Clipboard] <Clipboard>: F

Current settings: Output=File, Background=Normal

Setting to change [Output/Background/Exit] <Exit>: B

Force background color to white [Yes/No] <No>: Y

Current settings: Output=File, Background=ForceToWhite

Setting to change [Output/Background/Exit] <Exit>:

Current settings: Output=File, Background=ForceToWhite

Select first point of capture window or [Document/Application/Objects/Settings]: D

Regenerating model.

Regenerating model.

Command:

If you get the chance, please give the code a try and let me know what more you’d like to see the SCREENSHOT command do.

Design choices for the next Plugin of the Month

I’m currently thinking about using the code from this previous post as a basis for November’s Plugin of the Month.

This simple AutoCAD application would provide three main capabilities:

1. Take a screenshot of the entire AutoCAD application window
2. Take a screenshot of the current drawing window
3. Take a screenshot of a user-specified section of the current drawing

Each of these options would result in a bitmap being either saved to file or placed on the clipboard.

The thing I’m chewing on, right now, is how best to design the command interface for these operations. It occurred to me that this would make a fun topic for a blog post: why not throw it out there and gather some options? An experiment in crowdsourced product design. :-)

So, here are the options I’m considering:

• A single command (perhaps called CAPTURE or SCREENSHOT)
• Prompts:
1. Select first point of capture window or [Document/Application]
• If point selected…
• Select second point of capture window:
2. Save to file or place on the clipboard [File/Clipboard]:
• If “File” selected, file dialog appears, with various image format options:
• Select image location
• Pros
• Simplicity: a single command is easier to remember
• Cons
• Somewhat cumbersome, especially if regularly using only one of “copy to clipboard” and “save to file”
• Two commands (example names below)
• CAPTURECLIP [saves the results of the capture operation to the clipboard]
1. Select first point of capture window or [Document/Application]
• If point selected…
• Select second point of capture window:
• CAPTUREFILE [saves the results of the capture operation to a file]
1. Select first point of capture window or [Document/Application]
• If point selected…
• Select second point of capture window:
2. File dialog appears, with various image format options:
• Select image location
• Pros
• Streamlined for regular use
• Cons
• Double the commands: twice as complex for the user (OK, perhaps that’s not such a big deal… :-)

Overall I’m more in favour of the second choice, right now, as it feels like it’d be better suited for regular use.

Another option would be to have all 3 commands: the general command, CAPTURE, would probably be better for novices, and the specific commands, CAPTURECLIP & CAPTUREFILE, would probably be better for power-users. But that adds testing/coding/documentation complexity, which may well be unnecessary.

There are other options I haven’t listed, such as using some kind of application setting (like a system variable) to decide whether to save the captured image to file or copy it to the clipboard. I’d probably rather not go down that particular path, as it adds complexity and feels a little  less intuitive, but it’s certainly an option.

Does anyone out there have an opinion they’d like to share? If you suggest something compelling that leads to a change in the design of the plugin, I’ll be sure to give you credit in the supporting documentation. :-)