Drive AutoCAD with Code: February 2011

One of the technical issues CAD managers oftern ask thenself is how do I tracking plottings done through AutoCAD.

There are many ways to do that. AutoCAD itself provides plot and publish logging (via Options dialog box->Plot and Publish tab). There be other software that can monitor printing tasks sent to one or more printers...

With AutoCD .NET API, we can fairly easily to build a custom plotting logging application, which is the topic of this article.

The Autodesk.AutoCAD.PlottingServices.PlotReactorManager class provides all the functionalities needed to track plotting from an running AutoCAD session. This class exposes a series of events that fire from the beginning of plotting to the end of plotting. Some plotting information that would be the interest of plot tracking is exposed through various EventArgs. Therefore, simply handling approriate events and retrieving needed plotting information, then saving the information into some sort of data store, these all a custom plot tracking application needs to do.

Let's look at the code.

First, I define a data class that hold plotting information I want to track when AutoCAD does a plotting:

using System;

using Autodesk.AutoCAD.DatabaseServices;

namespace TrackAcadPlotting

    public class PlotLog

        public string DwgName { set; get; }

        public string DwgPath { set; get; }

        public int CopyCount { set; get; }

        public string PlotterName { set; get; }

        public DateTime PlottingTime { set; get; }

        public PlotPaperUnit PaperUnit { set; get; }

        public double PaperWidth { set; get; }

        public double PaperHeight { set; get; }

        public string MediaName { set; get; }

        public string UserName { set; get; }

        public string ComputerName { set; get; }

The data store used to save plot tracking data can be different, from file (plain text, Xml...), to database. AutoCAD built-in plotting log is a plain text file, usually saved where the the plotted drawing is, if enabled. Of course these kind of plotting logs are not convenient for plotting management: they scattered everywhere. In general, file based store is not very ideal solution with this custom plot tracking application: the user who runs AutoCAD, thus the plot tracking application, must have read/write permission to the log file. So, it could be a security hole, if you want this plot tracking to be a serious CAD management tool. Ideally, the data store would be some sort of central database.

In order for this custom plot tracking application to be able to save plotting log to different data store, I created an Interface called IPlottingLogWriter. For different data store, we can write different code to save the plotting log, as long as the IPlottingLogWriter is implemented. In this article, the the simplicity, I implemented an file data store, called PlottingLogFileWriter to save plotting log to a text file. As aforementioned, I could implement the IPlottingLogWriter to save the data to database, or send the plotting log data to a WCF service to be saved somewhere. This way, no matter what data storage mechanism the application uses, the code to track plotting will not have to be changed.
Here is the Interface and its implementing:

The interface:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace TrackAcadPlotting

    public interface IPlottingLogWriter

        void SavePlottingLog(PlotLog log);

The interface implementing:

using System;

using System.IO;

namespace TrackAcadPlotting

    public class PlottingLogFileWriter : IPlottingLogWriter

        private string _logFolder;

        public PlottingLogFileWriter(string folderPath)

            _logFolder = folderPath;

            //Create log folder:

            if (!Directory.Exists(_logFolder))

                Directory.CreateDirectory(_logFolder);

        #region IPlottingLogWriter Members

        public void SavePlottingLog(PlotLog log)

            string fileName = _logFolder +

                        "\\PlotTracking_" +

                        DateTime.Today.ToString("yyyy-MM-dd") +

                        ".txt";

            using (FileStream st = new FileStream(

                fileName, FileMode.Append, FileAccess.Write, FileShare.Write))

                using (StreamWriter writer = new StreamWriter(st))

                    writer.WriteLine(

                        "-------------Log begins------------------");

                    writer.WriteLine("Drawing: {0}",

                        log.DwgName);

                    writer.WriteLine("File path: {0}",

                        log.DwgPath);

                    writer.WriteLine("Plotting copy: {0}",

                        log.CopyCount);

                    writer.WriteLine("Plotter name: {0}",

                        log.PlotterName);

                    writer.WriteLine("Paper unit: {0}",

                        log.PaperUnit.ToString());

                    writer.WriteLine("Paper width: {0}",

                        log.PaperWidth.ToString("#######0.00") + "mm");

                    writer.WriteLine("Paper hight: {0}",

                        log.PaperHeight.ToString("#######0.00") + "mm");

                    writer.WriteLine("Media name: {0}",

                        log.MediaName);

                    writer.WriteLine("User name: {0}",

                        log.UserName);

                    writer.WriteLine("CAD computer: {0}",

                        log.ComputerName);

                    writer.WriteLine(

                        "-------------Log ends--------------------");

                    writer.Flush();

                    writer.Close();

        #endregion

Finally, this is the class "TrackPlotting" that does the actual work:

    1 using System;

    2 using System.Collections.Generic;

    3 using System.IO;

    5 using Autodesk.AutoCAD.ApplicationServices;

    6 using Autodesk.AutoCAD.EditorInput;

    7 using Autodesk.AutoCAD.PlottingServices;

    8 using Autodesk.AutoCAD.Geometry;

    9 using Autodesk.AutoCAD.Runtime;

   11 [assembly: CommandClass(typeof(TrackAcadPlotting.TrackPlotting))]

   12 [assembly: ExtensionApplication(typeof(TrackAcadPlotting.TrackPlotting))]

   14 namespace TrackAcadPlotting

   15 {

   16     public class TrackPlotting: IExtensionApplication

   17     {

   18         private static PlotReactorManager _plotManager;

   19         private static IPlottingLogWriter _logWriter;

   20         private static bool _cancelled=false;

   21         private static PlotLog _log=null;

   23         #region IExtensionApplication Members

   25         private List<string> _plotters = null;

   27         public void Initialize()

   28         {

   29             Document dwg = Autodesk.AutoCAD.ApplicationServices.

   30                 Application.DocumentManager.MdiActiveDocument;

   32             //Get plotter names to track

   33             _plotters = GetPlotterNames();

   35             try

   36             {

   37                 //Hard-coded log file folder path.

   38                 //In production, the file path could be

   39                 //set in acad.exe.confg or using other

   40                 //configuing technique

   41                 //Note: here I instantiated an PlottingLogFileWriter

   42                 //I can also instantiate an PlottingLogSqlServerWriter,

   43                 //if it is available

   44                 _logWriter = new PlottingLogFileWriter("E:\\Temp\\PlottingTrack");

   45             }

   46             catch

   47             {

   48                 if (dwg != null)

   49                 {

   50                     dwg.Editor.WriteMessage(

   51                         "\nInitializing plot tracking log writer faailed.");

   52                 }

   54                 return;

   55             }

   57             //Hook up event handlers

   58             _plotManager = new PlotReactorManager();

   60             _plotManager.BeginPlot +=

   61                 new BeginPlotEventHandler(PlotManager_BeginPlot);

   63             _plotManager.BeginDocument +=

   64                 new BeginDocumentEventHandler(PlotManager_BeginDocument);

   66             _plotManager.BeginPage +=

   67                 new BeginPageEventHandler(PlotManager_BeginPage);

   69             _plotManager.EndPage +=

   70                 new EndPageEventHandler(PlotManager_EndPage);

   72             _plotManager.EndDocument +=

   73                 new EndDocumentEventHandler(PlotManager_EndDocument);

   75             _plotManager.EndPlot +=

   76                 new EndPlotEventHandler(PlotManager_EndPlot);

   78             _plotManager.PageCancelled +=

   79                 new PageCancelledEventHandler(PlotManager_PageCancelled);

   81             _plotManager.PlotCancelled +=

   82                 new PlotCancelledEventHandler(PlotManager_PlotCancelled);

   84             if (dwg != null)

   85             {

   86                 dwg.Editor.WriteMessage("\nPlot tracking has been initialized.");

   87             }

   88         }

   90         public void Terminate()

   91         {

   92             //Remove event handlers

   93             _plotManager.BeginPlot -=

   94                 new BeginPlotEventHandler(PlotManager_BeginPlot);

   96             _plotManager.BeginDocument -=

   97                 new BeginDocumentEventHandler(PlotManager_BeginDocument);

   99             _plotManager.BeginPage -=

  100                 new BeginPageEventHandler(PlotManager_BeginPage);

  102             _plotManager.EndPage -=

  103                 new EndPageEventHandler(PlotManager_EndPage);

  105             _plotManager.EndDocument -=

  106                 new EndDocumentEventHandler(PlotManager_EndDocument);

  108             _plotManager.EndPlot +=

  109                 new EndPlotEventHandler(PlotManager_EndPlot);

  111             _plotManager.PageCancelled -=

  112                 new PageCancelledEventHandler(PlotManager_PageCancelled);

  114             _plotManager.PlotCancelled -=

  115                 new PlotCancelledEventHandler(PlotManager_PlotCancelled);

  116         }

  118         #endregion

  120         #region private methods

  122         private List<string> GetPlotterNames()

  123         {

  124             List<string> plotters = new List<string>();

  126             //A plotter name list could be stored somewhere

  127             //and loaded in, such as acad.exe.config (user may change it!)

  128             //Or centrally stored in a DB (so only manager can set/change it)

  129             //Here I simply hard-coded one plotter name

  130             plotters.Add("CutePDF Writer");

  132             return plotters;

  133         }

  135         private void GetUserComputerName(

  136             out string userName, out string computerName)

  137         {

  138             userName = "";

  139             computerName = "";

  141             string domain = System.Environment.UserDomainName;

  142             string user = System.Environment.UserName;

  144             userName = domain + "\\" + user;

  145             computerName = System.Environment.MachineName;

  146         }

  148         private bool IsTracedDevice(string plotterName)

  149         {

  150             foreach (string plt in _plotters)

  151             {

  152                 if (plt.Equals(plotterName,

  153                     StringComparison.CurrentCultureIgnoreCase))

  154                 {

  155                     return true;

  156                 }

  157             }

  159             return false;

  160         }

  162         #endregion

  164         #region Private methods: plotting event handlers

  166         private void PlotManager_BeginPlot(object sender, BeginPlotEventArgs e)

  167         {

  168             _cancelled = false;

  170             if (e.PlotType == Autodesk.AutoCAD.

  171                 PlottingServices.PlotType.BackgroundPlot

  172                 || e.PlotType == Autodesk.AutoCAD.

  173                 PlottingServices.PlotType.Plot)

  174             {

  176                 _log = new PlotLog();

  178                 string user;

  179                 string comp;

  180                 GetUserComputerName(out user, out comp);

  182                 _log.UserName = user;

  183                 _log.ComputerName = comp;

  184             }

  185             else

  186             {

  187                 _log = null;

  188             }

  189         }

  191         private void PlotManager_BeginDocument(

  192             object sender, BeginDocumentEventArgs e)

  193         {

  194             if (e.PlotToFile)

  195             {

  196                 _log = null;

  197                 return;

  198             }

  200             _log.DwgName = Path.GetFileName(e.DocumentName);

  201             _log.DwgPath = Path.GetDirectoryName(e.DocumentName);

  202             _log.CopyCount = e.Copies;

  203         }

  205         private void PlotManager_BeginPage(

  206             object sender, BeginPageEventArgs e)

  207         {

  208             if (_log == null) return;

  210             if (e.PlotInfo.ValidatedConfig != null)

  211             {

  212                 if (e.PlotInfo.ValidatedConfig.IsPlotToFile)

  213                 {

  214                     _log = null;

  215                     return;

  216                 }

  218                 _log.PlotterName = e.PlotInfo.ValidatedConfig.DeviceName;

  219             }

  221             if (e.PlotInfo.ValidatedSettings != null)

  222             {

  223                 _log.PaperUnit = e.PlotInfo.ValidatedSettings.PlotPaperUnits;

  224                 _log.MediaName = e.PlotInfo.ValidatedSettings.CanonicalMediaName;

  226                 Point2d pt = e.PlotInfo.ValidatedSettings.PlotPaperSize;

  227                 if (pt.X > pt.Y)

  228                 {

  229                     _log.PaperWidth = pt.X;

  230                     _log.PaperHeight = pt.Y;

  231                 }

  232                 else

  233                 {

  234                     _log.PaperWidth = pt.Y;

  235                     _log.PaperHeight = pt.X;

  236                 }

  237             }

  238         }

  240         private void PlotManager_EndPage(

  241             object sender, EndPageEventArgs e)

  242         {

  243             if (e.Status != SheetCancelStatus.Continue) _cancelled = true;

  244         }

  246         private void PlotManager_EndDocument(

  247             object sender, EndDocumentEventArgs e)

  248         {

  249             if (e.Status != PlotCancelStatus.Continue) _cancelled = true;

  250         }

  252         private void PlotManager_EndPlot(

  253             object sender, EndPlotEventArgs e)

  254         {

  255             if (e.Status != PlotCancelStatus.Continue) _cancelled = true;

  257             if (_cancelled)

  258             {

  259                 _log = null;

  260                 _cancelled = false;

  261                 return;

  262             }

  264             if (_log == null) return;

  266             _log.PlottingTime = DateTime.Now;

  268             //Debug code here

  269             Document dwg = Autodesk.AutoCAD.ApplicationServices.

  270                 Application.DocumentManager.MdiActiveDocument;

  271             Editor ed = dwg.Editor;

  273             ed.WriteMessage("\nPlotted by: {0}", _log.UserName);

  274             ed.WriteMessage("\nPlotted on: {0}", _log.PlotterName);

  275             ed.WriteMessage("\nDwg Location: {0}", _log.DwgPath);

  276             ed.WriteMessage("\nPlotted Dwg: {0}", _log.DwgName);

  277             ed.WriteMessage("\nMedia: {0}", _log.MediaName);

  278             ed.WriteMessage("\nMedia size: " +

  279                 _log.PaperWidth.ToString("#####0.00") +

  280                 " (W) x " +

  281                 _log.PaperHeight.ToString("#####0.00") + " (H)");

  282             ed.WriteMessage("\nCopy Count: {0}", _log.CopyCount);

  284             //Save Plotting log, if the plotting plotter is on printer list;

  285             if (IsTracedDevice(_log.PlotterName))

  286             {

  287                 _logWriter.SavePlottingLog(_log);

  288             }

  289         }

  291         private void PlotManager_PlotCancelled(object sender, EventArgs e)

  292         {

  293             _cancelled = true;

  294         }

  296         private void PlotManager_PageCancelled(object sender, EventArgs e)

  297         {

  298             _cancelled = true;

  299         }

  301         #endregion

  302     }

  303 }

Some descriptions of the code:

Line 16: this class implements IExtensionApplication. That means, as soon as the assembly is loaded, the code starts monitoring plotting done in the AutoCAD session.

Line 25 and Line 122 - 133: these lines of code defines a list of plotter/printer name that I want to track. The name should be the same as I can see in the printer dropdown list of AutoCAD's plot dialog box. Only plotters in this list is tracked.

Line 44: Notice the variable _logWriter is declared as IPlottingLogWriter, but here it points to a PlottingLogFileWriter (new PlottingLogFileWriter()). It is possible to declare the differently implemented IPlottingLogWriter in acad.exe.config, so that this class will be truly not affected when a new implemented log-writer is available/changed.

The rest of code would be quite obvious, no extra explanation is necessary.

This video clip shows how it works. Note, since I used CutePDF virtual plotter, each time after the plotting is done (e.g. the PDF has been produced), I simply cancelled the "Save As" dialog box. By then the plotting from AutoCAD has already completed, thus cancelling saving PDF file has no affect to the plot tracking process.

At my work, similar code is used to monitor AutoCAD plotting to some expensive color plotters office-wide. The plotting logs are saved to database and can be browsed by managers through a web application.

Finally, I'd like to thank Kean Walmsley for recommending me the VS addin tool CopySourceToHtml, which solves my code posting issue.

Drive AutoCAD with Code

Tuesday, February 15, 2011

Log AutoCAD's Plotting

Followers

About Me