Through the Interface

Filtering Windows messages inside AutoCAD using .NET

Back when I joined Autodesk in 1995, I worked in European Developer Support with one of the most talented programmers I've met, Markus Kraus. One of Markus' contributions to the R13 ARX SDK (or maybe it was R14?) was a sample called pretranslate, which remained on the SDK up until ObjectARX 2008, under samples/editor/mfcsamps/pretranslate (it was removed from the 2009 SDK when we archived a number of aging samples).

Anyway, with AutoCAD 2009 the API that makes this sample possible has been added to the .NET API, so in homage to Markus' original sample (which I have fond memories of demoing during a number of events around Europe), I decided to translate the original C++ sample to C#.

Here's the C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.Runtime;

using System.Windows.Interop;

using System;

namespace PreTranslate

{

  public class Commands

  {

    // Keys

    const int MK_SHIFT = 4;

    const int MK_CONTROL = 8;

    // Keyboard messages

    const int WM_KEYDOWN = 256;

    const int WM_KEYUP = 257;

    const int WM_CHAR = 258;

    const int WM_SYSKEYDOWN = 260;

    const int WM_SYSKEYUP = 261;

    // Mouse messages

    const int WM_MOUSEMOVE = 512;

    const int WM_LBUTTONDOWN = 513;

    const int WM_LBUTTONUP = 514;

    static long MakeLong(int LoWord, int HiWord)

    {

      return (HiWord << 16) | (LoWord & 0xffff);

    }

    static IntPtr MakeLParam(int LoWord, int HiWord)

    {

      return (IntPtr)MakeLong(LoWord,HiWord);

    }

    static int HiWord(int Number)

    {

      return (Number >> 16) & 0xffff;

    }

    static int LoWord(int Number)

    {

      return Number & 0xffff;

    }

    // State used by the VhmouseHandler to filter on

    // the vertical or the horizontal

    bool vMode;

    bool hMode;

    int ptx;

    int pty;

    // Commands to add/remove message handlers

    [CommandMethod("caps")]

    public void Caps()

    {

      Application.PreTranslateMessage +=

        new PreTranslateMessageEventHandler(CapsHandler);

    }

    [CommandMethod("uncaps")]

    public void UnCaps()

    {

      Application.PreTranslateMessage -=

        new PreTranslateMessageEventHandler(CapsHandler);

    }

    [CommandMethod("vhmouse")]

    public void Vhmouse()

    {

      Application.PreTranslateMessage +=

        new PreTranslateMessageEventHandler(VhmouseHandler);

    }

    [CommandMethod("unvhmouse")]

    public void UnVhmouse()

    {

      Application.PreTranslateMessage -=

        new PreTranslateMessageEventHandler(VhmouseHandler);

    }

    [CommandMethod("watchCC")]

    public void WatchCC()

    {

      Application.PreTranslateMessage +=

        new PreTranslateMessageEventHandler(WatchCCHandler);

    }

    [CommandMethod("unwatchCC")]

    public void UnWatchCC()

    {

      Application.PreTranslateMessage -=

        new PreTranslateMessageEventHandler(WatchCCHandler);

    }

    [CommandMethod("noX")]

    public void NoX()

    {

      Application.PreTranslateMessage +=

        new PreTranslateMessageEventHandler(NoXHandler);

    }

    [CommandMethod("yes")]

    public void YesX()

    {

      Application.PreTranslateMessage -=

        new PreTranslateMessageEventHandler(NoXHandler);

    }

    // The event handlers themselves...

    // Force alphabetic character entry to uppercase

    void CapsHandler(

      object sender,

      PreTranslateMessageEventArgs e

    )

    {

      // For every lowercase character message,

      // reduce it my 32 (which forces it to

      // uppercase in ASCII)

      if (e.Message.message == WM_CHAR &&

          (e.Message.wParam.ToInt32() >= 97 &&

          e.Message.wParam.ToInt32() <= 122))

      {

        MSG msg = e.Message;

        msg.wParam =

          (IntPtr)(e.Message.wParam.ToInt32() - 32);

        e.Message = msg;

      }

    }

    // Force mouse movement to either horizontal or

    // vertical

    void VhmouseHandler(

      object sender,

      PreTranslateMessageEventArgs e

    )

    {

      // Only look at mouse messages

      if (e.Message.message == WM_MOUSEMOVE ||

          e.Message.message == WM_LBUTTONDOWN ||

          e.Message.message == WM_LBUTTONUP)

      {

        // If the left mousebutton is pressed and we are

        // filtering horizontal or vertical movement,

        // make the position the one we're storing

        if ((e.Message.message == WM_LBUTTONDOWN ||

            e.Message.message == WM_LBUTTONUP)

            && (vMode ||  hMode))

        {

          MSG msg = e.Message;

          msg.lParam = MakeLParam(ptx, pty);

          e.Message = msg;

          return;

        }

        // If the Control key is pressed

        if (e.Message.wParam.ToInt32() == MK_CONTROL)

        {

          // If we're already in "vertical" mode,

          // set the horizontal component of our location

          // to the one we've stored

          // Otherwise we set the internal "x" value

          // (as this is the first time through)

          if (vMode)

          {

            MSG msg = e.Message;

            msg.lParam =

              MakeLParam(

                ptx,

                HiWord(e.Message.lParam.ToInt32())

              );

            e.Message = msg;

            pty = HiWord(e.Message.lParam.ToInt32());

          }

          else

            ptx = LoWord(e.Message.lParam.ToInt32());

          vMode = true;

          hMode = false;

        }

        // If the Shift key is pressed

        else if (e.Message.wParam.ToInt32() == MK_SHIFT)

        {

          // If we're already in "horizontal" mode,

          // set the vertical component of our location

          // to the one we've stored

          // Otherwise we set the internal "y" value

          // (as this is the first time through)

          if (hMode)

          {

            MSG msg = e.Message;

            msg.lParam =

              MakeLParam(

                LoWord(e.Message.lParam.ToInt32()),

                pty

              );

            e.Message = msg;

            ptx = LoWord(e.Message.lParam.ToInt32());

          }

          else

            pty = HiWord(e.Message.lParam.ToInt32());

          hMode = true;

          vMode = false;

        }

        else

          // Something else was pressed,

          // so cancel our filtering

          vMode = hMode = false;

      }

    }

    // Watch for Ctrl-C, and display a message

    void WatchCCHandler(

      object sender,

      PreTranslateMessageEventArgs e

    )

    {

      // Check for the Ctrl-C Windows message

      if (e.Message.message == WM_CHAR &&

          e.Message.wParam.ToInt32() == 3)

      {

        Document doc =

          Application.DocumentManager.MdiActiveDocument;

        doc.Editor.WriteMessage(

          "\nCtrl-C is pressed"

        );

      }

    }

    // Filter out use of the letter x/X

    void NoXHandler(

      object sender,

      PreTranslateMessageEventArgs e

    )

    {

      // If lowercase or uppercase x is pressed,

      // filter the message by setting the

      // Handled property to true

      if (e.Message.message == WM_CHAR &&

          (e.Message.wParam.ToInt32() == 120 ||

          e.Message.wParam.ToInt32() == 88))

        e.Handled = true;

    }

  }

}

To be able to use the System.Windows.Interop namespace, you'll need to add a project reference to WindowsBase.dll. Strangely this can take some finding - at least on my system it wasn't included in the base assembly list. To find it, I browsed to:

C:\Program Files\Reference Assemblies\Microsoft\Framework\v3.0\WindowsBase.dll

The application defines a number of commands, which are described in this text from the original sample's ReadMe:

This sample shows how to pretranslate AutoCAD messages

before they're processed by AutoCAD.

In order to pre-processe AutoCAD messages, a hook function

needs to be installed. The following commands install

different hook functions.

- vhmouse/unvhmouse

  Installs/uninstalls a hook that makes the mouse move only in a

  vertical direction if <CTRL> key is pressed, and only in a

  horizontal direction if the <SHIFT> key is pressed.

- caps/uncaps

  Installs/uninstalls a hook that capitalizes all

  letters typed in the command window.

- noX/yes

  Installs/uninstalls a hook that filters out the

  letters 'x' or 'X'.

- watchCC/unwatchCC

  Installs/uninstalls a hook that watchs

  for <CTRL>+C key combination to be pressed.

Here's what happens when we run the various commands:

Command: caps

Command: UNCAPS

Command: vhmouse

Command: unvhmouse

Command: watchcc

Command:

Ctrl-C is pressed

Command:

Command: _copyclip

Select objects: *Cancel*

Command: nox

Command: yes

While you can't see all the effects of the various commands from this dump of the command-line, here are some comments and pointers, should you try this sample:

• The Shift or Caps Lock keys was not used at all during entry of the command-names
• During the vhmouse command, move the mouse around and use the Shift and Ctrl keys to force the movement to horizontal or vertical
  • The Ctrl key now shows an entity selection cursor in AutoCAD, so I should probably have changed to another key for this, but anyway
• Ctrl-C now launches COPYCLIP, but we see the message first
• The yes command should obviously be called yesx, but then we can't enter the "x" character after running the nox command. :-)

As a final note: I don't recommend filtering commonly-used keystrokes in your application - your users really won't thank you - but this fun little sample at least shows you the capabilities of the PreTranslate mechanism.

Generating fractals inside AutoCAD using F#

Some of you may remember my interest in fractals from these two previous posts. Well, while researching a problem in F# (related to the conversion of the last post's code to F#), I stumbled across this post from Luke Hoban, which contains some neat, recursive F# code to generate the Mandelbrot set, sending the result to the console as ASCII text. I couldn't resist modifying the code to generate Solids (filled shapes with 3 or 4 sides, as opposed to Solid3d objects) inside AutoCAD.

Here's the F# code:

#light

module Mandelbrot

#I @"C:\Program Files\Autodesk\AutoCAD 2009"

#r "acdbmgd.dll"

#r "acmgd.dll"

#nowarn "57"

open Autodesk.AutoCAD.Runtime

open Autodesk.AutoCAD.ApplicationServices

open Autodesk.AutoCAD.EditorInput

open Autodesk.AutoCAD.DatabaseServices

open Autodesk.AutoCAD.Geometry

open System

open Microsoft.FSharp.Math

let maxIteration = 50

let granularity = 400

let modSquared (c : Complex) = c.r * c.r + c.i * c.i

type MandelbrotResult =

    | DidNotEscape

    | Escaped of int

let mandelbrot c =

  let rec mandelbrotInner z iterations =

    if(modSquared z >= 4.0)

      then Escaped iterations

    elif iterations = maxIteration

      then DidNotEscape

    else mandelbrotInner ((z * z) + c) (iterations + 1)

  mandelbrotInner c 0

[<CommandMethod("MB")>]

let drawMandelbrot () =

  let doc =

    Application.DocumentManager.MdiActiveDocument

  let ed = doc.Editor

  let db = doc.Database

  let tm = doc.TransactionManager

  use tr =

    tm.StartTransaction()

  // Get appropriately-typed BlockTable and BTR

  let bt =

    tr.GetObject

      (db.BlockTableId,OpenMode.ForRead)

    :?> BlockTable

  let ms =

    tr.GetObject

      (bt.[BlockTableRecord.ModelSpace],

      OpenMode.ForWrite)

    :?> BlockTableRecord

  // Now let's create our geometry

  let xgran = 1.0 / Int32.to_float granularity

  let ygran = 1.0 / Int32.to_float granularity

  for y in [-1.0..xgran..1.0] do

    for x in [-2.0..ygran..1.0] do

      match mandelbrot (Complex.Create (x, y)) with

      | DidNotEscape ->

        let pt =

          new Solid

            (new Point3d(x,y,0.0),

             new Point3d(x+xgran,y,0.0),

             new Point3d(x,y+ygran,0.0),

             new Point3d(x+xgran,y+ygran,0.0))

        ms.AppendEntity(pt) |> ignore

        tr.AddNewlyCreatedDBObject(pt, true)

      | Escaped _ -> ()

    tm.QueueForGraphicsFlush()

    tm.FlushGraphics()

    ed.UpdateScreen()

  tr.Commit()

And here's what happens when we run the MB command:

Here's a zoomed in area, so you can see the pixelation effect of using square Solids:

You can, of course, vary the maxIteration and granularity parameters in the code, if you want to play around with the results (or even modify the code to ask for the values at the command-line, to save rebuilding the app all the time).

A quick note: at first the app was running slowly and causing memory issues, before I enabled the 3Gb switch on my Vista machine. Now things are much better, but then that could also be because I've just rebooted. :-)

Sectioning an AutoCAD solid using .NET

In the last post we saw how to access some of the 3D modeling functionality introduced in AutoCAD 2007. This post continues that theme, by looking at how to section a Solid3d object programmatically inside AutoCAD. Thanks to Wayne Brill, from DevTech Americas, for providing the original code that inspired this post.

Here's the C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Geometry;

using System;

namespace SolidSection

{

  public class Commands

  {

    [CommandMethod("SS")]

    public void SectionSolid()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

      // Ask the user to select an entity to section

      PromptEntityOptions peo =

        new PromptEntityOptions(

          "\nSelect entity to section: "

        );

      peo.SetRejectMessage(

        "\nEntity must be a 3D solid, " +

        "surface, body or region."

      );

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

      peo.AddAllowedClass(

        typeof(Autodesk.AutoCAD.DatabaseServices.Surface),

        false

      );

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

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

      PromptEntityResult per =

        ed.GetEntity(peo);

      if (per.Status != PromptStatus.OK)

        return;

      ObjectId entId =

        per.ObjectId;

      // Ask the user to define a section plane

      Point3dCollection pts =

        new Point3dCollection();

      PromptPointResult ppr =

        ed.GetPoint("\nPick first point for section: ");

      if (ppr.Status != PromptStatus.OK)

        return;

      pts.Add(ppr.Value);

      PromptPointOptions ppo =

        new PromptPointOptions(

          "\nPick end point for section: "

        );

      ppo.BasePoint = ppr.Value;

      ppo.UseBasePoint = true;

      ppr =

        ed.GetPoint(ppo);

      if (ppr.Status != PromptStatus.OK)

        return;

      pts.Add(ppr.Value);

      // Ask what type of section to create

      PromptKeywordOptions pko =

        new PromptKeywordOptions(

          "Enter section type "

        );

      pko.AllowNone = true;

      pko.Keywords.Add("2D");

      pko.Keywords.Add("3D");

      pko.Keywords.Add("Live");

      pko.Keywords.Default = "3D";

      PromptResult pkr =

        ed.GetKeywords(pko);

      if (pkr.Status != PromptStatus.OK)

        return;

      SectionType st;

      if (pkr.StringResult == "2D")

        st = SectionType.Section2d;

      else if (pkr.StringResult == "Live")

        st = SectionType.LiveSection;

      else // pkr.StringResult == "3D"

        st = SectionType.Section3d;

      // Now we're ready to do the real work

      Transaction tr =

        db.TransactionManager.StartTransaction();

      using (tr)

      {

        try

        {

          BlockTable bt =

            (BlockTable)tr.GetObject(

              db.BlockTableId,

              OpenMode.ForRead

            );

          BlockTableRecord ms =

            (BlockTableRecord)tr.GetObject(

              bt[BlockTableRecord.ModelSpace],

              OpenMode.ForWrite

            );

          // Now let's create our section

          Section sec =

            new Section(pts, Vector3d.ZAxis);

          sec.State = SectionState.Plane;

          // The section must be added to the drawing

          ObjectId secId =

            ms.AppendEntity(sec);

          tr.AddNewlyCreatedDBObject(sec, true);

          // Set up some of its direct properties

          sec.SetHeight(

            SectionHeight.HeightAboveSectionLine,

            3.0

          );

          sec.SetHeight(

            SectionHeight.HeightBelowSectionLine,

            1.0

          );

          // ... and then its settings

          SectionSettings ss =

            (SectionSettings)tr.GetObject(

              sec.Settings,

              OpenMode.ForWrite

            );

          // Set our section type

          ss.CurrentSectionType = st;

          // We only set one additional option if "Live"

          if (st == SectionType.LiveSection)

            sec.EnableLiveSection(true);

          else

          {

            // Non-live (i.e. 2D or 3D) settings

            ObjectIdCollection oic =

              new ObjectIdCollection();

            oic.Add(entId);

            ss.SetSourceObjects(st, oic);

            if (st == SectionType.Section2d)

            {

              // 2D-specific settings

              ss.SetVisibility(

                st,

                SectionGeometry.BackgroundGeometry,

                true

              );

              ss.SetHiddenLine(

                st,

                SectionGeometry.BackgroundGeometry,

                false

              );

            }

            else if (st == SectionType.Section3d)

            {

              // 3D-specific settings

              ss.SetVisibility(

                st,

                SectionGeometry.ForegroundGeometry,

                true

              );

            }

            // Finish up the common 2D/3D settings

            ss.SetGenerationOptions(

              st,

              SectionGeneration.SourceSelectedObjects |

              SectionGeneration.DestinationFile

            );

          }

          // Open up the main entity

          Entity ent =

            (Entity)tr.GetObject(

              entId,

              OpenMode.ForRead

            );

          // Generate the section geometry

          Array flEnts, bgEnts, fgEnts, ftEnts, ctEnts;

          sec.GenerateSectionGeometry(

            ent,

            out flEnts,

            out bgEnts,

            out fgEnts,

            out ftEnts,

            out ctEnts

          );

          // Add the geometry to the modelspace

          // (start by combining the various arrays,

          // so we then have one loop, not four)

          int numEnts =

            flEnts.Length + fgEnts.Length +

            bgEnts.Length + ftEnts.Length +

            ctEnts.Length;

          // Create the appropriately-sized array

          Array ents =

          Array.CreateInstance(

            typeof(Entity),

            numEnts

          );

          // Copy across the contents of the

          // various arrays

          int index = 0;

          flEnts.CopyTo(ents, index);

          index += flEnts.Length;

          fgEnts.CopyTo(ents, index);

          index += fgEnts.Length;

          bgEnts.CopyTo(ents, index);

          index += bgEnts.Length;

          ftEnts.CopyTo(ents, index);

          index += ftEnts.Length;

          ctEnts.CopyTo(ents, index);

          // Our single loop to add entities

          foreach (Entity ent2 in ents)

          {

            ms.AppendEntity(ent2);

            tr.AddNewlyCreatedDBObject(ent2, true);

          }

          tr.Commit();

        }

        catch (System.Exception ex)

        {

          ed.WriteMessage(

            "\nException: " + ex.Message

          );

        }

      }

    }

  }

}

To see the results of the various options in the SS command, I created three identical spheres in an empty drawing:

I then used the SS command, selecting each sphere in turn and selecting a similar section line for each (as close as I could get without measuring), choosing, of course, a different command option each time (2D, 3D and Live, from left to right):

Orbitting this view, we see the section planes for each sphere:

The objects we've added to the drawing for the two left-hand sections are basic (2D or 3D, depending) geometry. The third, however, includes a section object:

A quick note on the code at the end which adds the various generated geometry to the drawing: in order to avoid having multiple foreach loops (one for each of flEnts, fgEnts, bgEnts, ftEnts & ctEnts), I opted to create an über-array which then gets populated by the contents of each of the other lists. This simple exercise was a pain in C#, as you can see from the code. In fact, having five separate loops could probably be considered less ugly, depending on your perspective. This is the kind of operation that's a breeze in a language like F#, and, with hindsight, I probably should have chosen F# from the beginning for just that reason. Maybe I'll throw an F# version together for comparison's sake.

Update

In AutoCAD 2010, Section.EnableLiveSection(bool) has become a Boolean property. For the above code to work in AutoCAD 2010, change the line containing the call to sec.EnableLiveSection(true) to:

sec.IsLiveSectionEnabled = true;

Sweeping an AutoCAD surface using .NET

AutoCAD 2007 introduced more advanced solid & surface modeling tools. This post takes a look at how to generate one particular type of surface: a SweptSurface, which is created by sweeping a profile (which could be a region, a planar surface or a curve) through a particular path (which must be a curve).

The below C# code shows how to sweep an object along a curved path to create a surface. Our SAP (for SweepAlongPath) command doesn't provide all the options of the standard SWEEP command, as the point is to show how to do this programmatically, not to duplicate standard AutoCAD functionality.

We're creating a SweptSurface in our code: it's also possible to sweep a similar entity along a path to create a Solid3d, but at the time of writing this is only exposed through ObjectARX (AcDb3dSolid::createSweptSolid()). If you have a strong need to create swept solids in AutoCAD using .NET, please send me an email.

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Geometry;

namespace SolidCreation

{

  public class Commands

  {

    [CommandMethod("SAP")]

    public void SweepAlongPath()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

      // Ask the user to select a region to extrude

      PromptEntityOptions peo1 =

        new PromptEntityOptions(

          "\nSelect profile or curve to sweep: "

        );

      peo1.SetRejectMessage(

        "\nEntity must be a region, curve or planar surface."

      );

      peo1.AddAllowedClass(

        typeof(Region), false);

      peo1.AddAllowedClass(

        typeof(Curve), false);

      peo1.AddAllowedClass(

        typeof(PlaneSurface), false);

      PromptEntityResult per =

        ed.GetEntity(peo1);

      if (per.Status != PromptStatus.OK)

        return;

      ObjectId regId = per.ObjectId;

      // Ask the user to select an extrusion path

      PromptEntityOptions peo2 =

        new PromptEntityOptions(

          "\nSelect path along which to sweep: "

        );

      peo2.SetRejectMessage(

        "\nEntity must be a curve."

      );

      peo2.AddAllowedClass(

        typeof(Curve), false);

      per = ed.GetEntity(peo2);

      if (per.Status != PromptStatus.OK)

        return;

      ObjectId splId = per.ObjectId;

      // Now let's create our swept surface

      Transaction tr =

        db.TransactionManager.StartTransaction();

      using (tr)

      {

        try

        {

          Entity sweepEnt =

            tr.GetObject(regId, OpenMode.ForRead) as Entity;

          Curve pathEnt =

            tr.GetObject(splId, OpenMode.ForRead) as Curve;

          if (sweepEnt == null || pathEnt == null)

          {

            ed.WriteMessage(

              "\nProblem opening the selected entities."

            );

            return;

          }

          // We use a builder object to create

          // our SweepOptions

          SweepOptionsBuilder sob =

            new SweepOptionsBuilder();

          // Align the entity to sweep to the path

          sob.Align =

            SweepOptionsAlignOption.AlignSweepEntityToPath;

          // The base point is the start of the path

          sob.BasePoint = pathEnt.StartPoint;

          // The profile will rotate to follow the path

          sob.Bank = true;

          // Now generate the surface...

          SweptSurface ss =

            new SweptSurface();

          ss.CreateSweptSurface(

            sweepEnt,

            pathEnt,

            sob.ToSweepOptions()

          );

          // ... and add it to the modelspace

          BlockTable bt =

            (BlockTable)tr.GetObject(

              db.BlockTableId,

              OpenMode.ForRead

            );

          BlockTableRecord ms =

            (BlockTableRecord)tr.GetObject(

              bt[BlockTableRecord.ModelSpace],

              OpenMode.ForWrite

            );

          ms.AppendEntity(ss);

          tr.AddNewlyCreatedDBObject(ss, true);

          tr.Commit();

        }

        catch

        { }

      }

    }

  }

}

Here's an image of a very simple drawing I used to demonstrate the function. I started by creating a helix, and then copied it, essentially creating my two paths. I then drew a tiny circle at the end point of the first helix (not aligned to the path in any way - just flat in the World UCS - as the SweepOptions we choose will ask that the profile to be aligned automatically to the path), and drew a simple "S"-shaped spline at the end point of the second helix (I drew the spline elsewhere and moved it using the mid-point as a base point, selecting the end of the helix as the destination).

So we end up with two paths (both helixes) and their respective non-aligned profiles (one a circle, the other a spline):

I then ran the SAP command twice, selecting one of the profiles and its respective path each time. Here's the 2D wireframe view of what was created:

To see the geometry better, I then changed to use the conceptual visual style and orbitted around to get a better 3D view:

Update

As mentioned in this post, Solid3d.CreateSweptSolid has now been implemented in AutoCAD 2010.

Update 2

And you can see the how to use Solid3d.CreateSweptSolid in this post.

Autodesk Design Review 2009 API documentation now available

Those of you developing with Autodesk Design Review will be happy to find out that the ADR API documentation for the 2009 release is now available on Beyond the Paper. Enjoy!

Deleting unused annotation scales in AutoCAD using .NET

Back in this previous post we looked at some code to add new annotation scales and attach them to textual entities inside AutoCAD. As a comment on that post, someone requested information on how to safely delete annotation scales from a drawing. I (very) speculatively responded, at the time, that it was probably appropriate to use Database.Purge() to make sure there were no dependencies on the scales before erasing them. I've just seen an internal email confirming this, so I thought I'd write it up in a quick post. [As a side not, this is presumably the technique used in the scale list cleanup utility.]

Here's the C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

namespace AnnotationScaling

{

  public class Commands

  {

    [CommandMethod("ASD")]

    public void DeleteAll()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

      ObjectContextManager ocm =

        db.ObjectContextManager;

      if (ocm != null)

      {

        // Now get the Annotation Scaling context collection

        // (named ACDB_ANNOTATIONSCALES_COLLECTION)

        ObjectContextCollection occ =

          ocm.GetContextCollection("ACDB_ANNOTATIONSCALES");

        if (occ != null)

        {

          // Create a collection to collect the IDs

          ObjectIdCollection oic =

            new ObjectIdCollection();

          foreach (ObjectContext oc in occ)

          {

            if (oc is AnnotationScale)

              oic.Add(

                new ObjectId(oc.UniqueIdentifier)

              );

          }

          // Check the object references using Purge

          // (this does NOT purge the objects, it only

          // filters the objects that are not purgable)

          db.Purge(oic);

          // Now let's erase each of the objects left

          Transaction tr =

            db.TransactionManager.StartTransaction();

          using (tr)

          {

            // Maintain a count which we decrement for

            // each error we receive on open/erase

            int count = oic.Count;

            foreach (ObjectId id in oic)

            {

              try

              {

                DBObject obj =

                  tr.GetObject(id, OpenMode.ForWrite);

                obj.Erase();

              }

              catch

              {

                count--;

              }

            }

            tr.Commit();

            // Inform the user of the results

            ed.WriteMessage(

              "\n{0} annotation scale{1} removed.",

              count,

              count == 1 ? "" : "s"

            );

          }

        }

      }

    }

  }

}

To test this, take a look at the number of annotation scales by running the SCALELISTEDIT command in a new drawing (based on acad.dwt):

Here's what happens when we run the ASD command:

Command: ASD

32 annotation scales removed.

And here's the greatly-reduced list of annotation scale objects when we re-run SCALELISTEDIT:

An automatic numbering system for AutoCAD blocks using .NET - Part 4

In the original post in this series, we introduced a basic application to number AutoCAD objects, specifically blocks with attributes. In the second post we extended this to make use of a generic numbering system for drawing-resident AutoCAD objects, and in the third post we implemented additional commands to take advantage of this new "kernel".

In this post we're going to extend the application in a few ways: firstly we're going to support duplicates, so that the LNS command which parses the current drawing to understand its numbers will support automatic and semi-automatic renumbering of objects with duplicate numbers. In addition there are a number of new event handlers that have been introduced to automatically renumber objects on creation/insertion/copy, and also to clear the numbering system when a user undoes any action in the drawing (just to be safe :-).

While introducing these event handlers I decide to switch the approach for associating data with a drawing: rather than declaring the variables at a class level and assuming they would be duplicated instantiated appropriately per-document, as shown in this previous post, I decided to encapsulate the variables in a class and specifically instantiate that class and store it per-document, as shown in this previous post.

Here's the updated C# code, with the changed & new lines in red, and here is the complete source file to save you having to strip line numbers:

    1 using Autodesk.AutoCAD.ApplicationServices;

    2 using Autodesk.AutoCAD.Runtime;

    3 using Autodesk.AutoCAD.DatabaseServices;

    4 using Autodesk.AutoCAD.EditorInput;

    5 using Autodesk.AutoCAD.Geometry;

    6 using System.Collections.Generic;

    7 using System.Collections;

    8

    9 namespace AutoNumberedBubbles

   10 {

   11   public class Commands : IExtensionApplication

   12   {

   13     // Strings identifying the block

   14     // and the attribute name to use

   15

   16     const string blockName = "BUBBLE";

   17     const string attbName = "NUMBER";

   18

   19     // A string to identify our application's

   20     // data in per-document UserData

   21

   22     const string dataKey = "TTIFBubbles";

   23

   24     // Define a class for our custom data

   25

   26     public class BubbleData

   27     {

   28       // A separate object to manage our numbering

   29

   30       private NumberedObjectManager m_nom;

   31       public NumberedObjectManager Nom

   32       {

   33         get { return m_nom; }

   34       }

   35

   36       // A "base" index (for the start of the list)

   37

   38       private int m_baseNumber;

   39       public int BaseNumber

   40       {

   41         get { return m_baseNumber; }

   42         set { m_baseNumber = value; }

   43       }

   44

   45       // A list of blocks added to the database

   46       // which we will then renumber

   47

   48       private List<ObjectId> m_blocksAdded;

   49       public List<ObjectId> BlocksToRenumber

   50       {

   51         get { return m_blocksAdded; }

   52       }

   53

   54       // Constructor

   55

   56       public BubbleData()

   57       {

   58         m_baseNumber = 0;

   59         m_nom = new NumberedObjectManager();

   60         m_blocksAdded = new List<ObjectId>();

   61       }

   62

   63       // Method to clear the contents

   64

   65       public void Reset()

   66       {

   67         m_baseNumber = 0;

   68         m_nom.Clear();

   69         m_blocksAdded.Clear();

   70       }

   71     }

   72

   73     // Constructor

   74

   75     public Commands()

   76     {

   77     }

   78

   79     // Functions called on initialization & termination

   80

   81     public void Initialize()

   82     {

   83       try

   84       {

   85         DocumentCollection dm =

   86           Application.DocumentManager;

   87         Document doc = dm.MdiActiveDocument;

   88         Database db = doc.Database;

   89         Editor ed = doc.Editor;

   90

   91         ed.WriteMessage(

   92           "\nLNS  Load numbering settings by analyzing the current drawing" +

   93           "\nDMP  Print internal numbering information" +

   94           "\nBAP  Create bubbles at points" +

   95           "\nBIC  Create bubbles at the center of circles" +

   96           "\nMB  Move a bubble in the list" +

   97           "\nDB  Delete a bubble" +

   98           "\nRBS  Reorder the bubbles, to close gaps caused by deletion" +

   99           "\nHLB  Highlight a particular bubble"

  100         );

  101

  102         // Hook into some events, to detect and renumber

  103         // blocks added to the database

  104

  105         db.ObjectAppended +=

  106           new ObjectEventHandler(

  107             db_ObjectAppended

  108           );

  109         dm.DocumentCreated +=

  110           new DocumentCollectionEventHandler(

  111             dm_DocumentCreated

  112           );

  113         dm.DocumentLockModeWillChange +=

  114           new DocumentLockModeWillChangeEventHandler(

  115             dm_DocumentLockModeWillChange

  116           );

  117

  118         doc.CommandEnded +=

  119           delegate(object sender, CommandEventArgs e)

  120           {

  121             if (e.GlobalCommandName == "UNDO" ||

  122                 e.GlobalCommandName == "U")

  123             {

  124               ed.WriteMessage(

  125                 "\nUndo invalidates bubble numbering: call" +

  126                 " LNS to reload the numbers for this drawing"

  127               );

  128               GetBubbleData((Document)sender).Reset();

  129             }

  130           };

  131       }

  132       catch

  133       { }

  134     }

  135

  136     public void Terminate()

  137     {

  138     }

  139

  140     // Method to retrieve (or create) the

  141     // BubbleData object for a particular

  142     // document

  143

  144     private BubbleData GetBubbleData(Document doc)

  145     {

  146       Hashtable ud = doc.UserData;

  147       BubbleData bd =

  148         ud[dataKey] as BubbleData;

  149

  150       if (bd == null)

  151       {

  152         object obj = ud[dataKey];

  153         if (obj == null)

  154         {

  155           // Nothing there

  156

  157           bd = new BubbleData();

  158           ud.Add(dataKey, bd);

  159         }

  160         else

  161         {

  162           // Found something different instead

  163

  164           Editor ed = doc.Editor;

  165           ed.WriteMessage(

  166             "Found an object of type \"" +

  167             obj.GetType().ToString() +

  168             "\" instead of BubbleData.");

  169         }

  170       }

  171       return bd;

  172     }

  173

  174     // Do the same for a particular database

  175

  176     private BubbleData GetBubbleData(Database db)

  177     {

  178       DocumentCollection dm =

  179         Application.DocumentManager;

  180       Document doc =

  181         dm.GetDocument(db);

  182       return GetBubbleData(doc);

  183     }

  184

  185     // When a new document is created, attach our

  186     // ObjectAppended event handler to the new

  187     // database

  188

  189     void dm_DocumentCreated(

  190       object sender,

  191       DocumentCollectionEventArgs e

  192     )

  193     {

  194       e.Document.Database.ObjectAppended +=

  195         new ObjectEventHandler(

  196           db_ObjectAppended

  197         );

  198     }

  199

  200     // When an object is appended to a database,

  201     // add it to a list we care about if it's a

  202     // BlockReference

  203

  204     void db_ObjectAppended(

  205       object sender,

  206       ObjectEventArgs e

  207     )

  208     {

  209       BlockReference br =

  210         e.DBObject as BlockReference;

  211       if (br != null)

  212       {

  213         BubbleData bd =

  214           GetBubbleData(e.DBObject.Database);

  215         bd.BlocksToRenumber.Add(br.ObjectId);

  216       }

  217     }

  218

  219     // When the command (or action) is over,

  220     // take the list of blocks to renumber and

  221     // go through them, renumbering each one

  222

  223     void dm_DocumentLockModeWillChange(

  224       object sender,

  225       DocumentLockModeWillChangeEventArgs e

  226     )

  227     {

  228       Document doc = e.Document;

  229       BubbleData bd =

  230         GetBubbleData(doc);

  231

  232       if (bd.BlocksToRenumber.Count > 0)

  233       {

  234         Database db = doc.Database;

  235         Transaction tr =

  236           db.TransactionManager.StartTransaction();

  237         using (tr)

  238         {

  239           foreach (ObjectId bid in bd.BlocksToRenumber)

  240           {

  241             try

  242             {

  243               BlockReference br =

  244                 tr.GetObject(bid, OpenMode.ForRead)

  245                 as BlockReference;

  246               if (br != null)

  247               {

  248                 BlockTableRecord btr =

  249                   (BlockTableRecord)tr.GetObject(

  250                     br.BlockTableRecord,

  251                     OpenMode.ForRead

  252                 );

  253                 if (btr.Name == blockName)

  254                 {

  255                   AttributeCollection ac =

  256                     br.AttributeCollection;

  257

  258                   foreach (ObjectId aid in ac)

  259                   {

  260                     DBObject obj =

  261                       tr.GetObject(aid, OpenMode.ForRead);

  262                     AttributeReference ar =

  263                       obj as AttributeReference;

  264

  265                     if (ar.Tag == attbName)

  266                     {

  267                       // Change the one we care about

  268

  269                       ar.UpgradeOpen();

  270

  271                       int bubbleNumber =

  272                         bd.BaseNumber +

  273                         bd.Nom.NextObjectNumber(bid);

  274                       ar.TextString =

  275                         bubbleNumber.ToString();

  276

  277                       break;

  278                     }

  279                   }

  280                 }

  281               }

  282             }

  283             catch { }

  284           }

  285           tr.Commit();

  286           bd.BlocksToRenumber.Clear();

  287         }

  288       }

  289     }

  290

  291     // Command to extract and display information

  292     // about the internal numbering

  293

  294     [CommandMethod("DMP")]

  295     public void DumpNumberingInformation()

  296     {

  297       Document doc =

  298         Application.DocumentManager.MdiActiveDocument;

  299       Editor ed = doc.Editor;

  300       BubbleData bd =

  301         GetBubbleData(doc);

  302       bd.Nom.DumpInfo(ed);

  303     }

  304

  305     // Command to analyze the current document and

  306     // understand which indeces have been used and

  307     // which are currently free

  308

  309     [CommandMethod("LNS")]

  310     public void LoadNumberingSettings()

  311     {

  312       Document doc =

  313         Application.DocumentManager.MdiActiveDocument;

  314       Database db = doc.Database;

  315       Editor ed = doc.Editor;

  316       BubbleData bd =

  317         GetBubbleData(doc);

  318

  319       // We need to clear any internal state

  320       // already collected

  321

  322       bd.Reset();

  323

  324       // Select all the blocks in the current drawing

  325

  326       TypedValue[] tvs =

  327         new TypedValue[1] {

  328             new TypedValue(

  329               (int)DxfCode.Start,

  330               "INSERT"

  331             )

  332           };

  333       SelectionFilter sf =

  334         new SelectionFilter(tvs);

  335

  336       PromptSelectionResult psr =

  337         ed.SelectAll(sf);

  338

  339       // If it succeeded and we have some blocks...

  340

  341       if (psr.Status == PromptStatus.OK &&

  342           psr.Value.Count > 0)

  343       {

  344         Transaction tr =

  345           db.TransactionManager.StartTransaction();

  346         using (tr)

  347         {

  348           // First get the modelspace and the ID

  349           // of the block for which we're searching

  350

  351           BlockTableRecord ms;

  352           ObjectId blockId;

  353

  354           if (GetBlock(

  355                 db, tr, out ms, out blockId

  356             ))

  357           {

  358             // For each block reference in the drawing...

  359

  360             foreach (SelectedObject o in psr.Value)

  361             {

  362               DBObject obj =

  363                 tr.GetObject(o.ObjectId, OpenMode.ForRead);

  364               BlockReference br = obj as BlockReference;

  365               if (br != null)

  366               {

  367                 // If it's the one we care about...

  368

  369                 if (br.BlockTableRecord == blockId)

  370                 {

  371                   // Check its attribute references...

  372

  373                   int pos = -1;

  374                   AttributeCollection ac =

  375                     br.AttributeCollection;

  376

  377                   foreach (ObjectId id in ac)

  378                   {

  379                     DBObject obj2 =

  380                       tr.GetObject(id, OpenMode.ForRead);

  381                     AttributeReference ar =

  382                       obj2 as AttributeReference;

  383

  384                     // When we find the attribute

  385                     // we care about...

  386

  387                     if (ar.Tag == attbName)

  388                     {

  389                       try

  390                       {

  391                         // Attempt to extract the number from

  392                         // the text string property... use a

  393                         // try-catch block just in case it is

  394                         // non-numeric

  395

  396                         pos =

  397                           int.Parse(ar.TextString);

  398

  399                         // Add the object at the appropriate

  400                         // index

  401

  402                         bd.Nom.NumberObject(

  403                           o.ObjectId, pos, false, true

  404                         );

  405                       }

  406                       catch { }

  407                     }

  408                   }

  409                 }

  410               }

  411             }

  412           }

  413           tr.Commit();

  414         }

  415

  416         // Once we have analyzed all the block references...

  417

  418         int start = bd.Nom.GetLowerBound(true);

  419

  420         // If the first index is non-zero, ask the user if

  421         // they want to rebase the list to begin at the

  422         // current start position

  423

  424         if (start > 0)

  425         {

  426           ed.WriteMessage(

  427             "\nLowest index is {0}. ",

  428             start

  429           );

  430           PromptKeywordOptions pko =

  431             new PromptKeywordOptions(

  432               "Make this the start of the list?"

  433             );

  434           pko.AllowNone = true;

  435           pko.Keywords.Add("Yes");

  436           pko.Keywords.Add("No");

  437           pko.Keywords.Default = "Yes";

  438

  439           PromptResult pkr =

  440             ed.GetKeywords(pko);

  441

  442           if (pkr.Status != PromptStatus.OK)

  443             bd.Reset();

  444           else

  445           {

  446             if (pkr.StringResult == "Yes")

  447             {

  448               // We store our own base number

  449               // (the object used to manage objects

  450               // always uses zero-based indeces)

  451

  452               bd.BaseNumber = start;

  453               bd.Nom.RebaseList(bd.BaseNumber);

  454             }

  455           }

  456         }

  457

  458         // We found duplicates in the numbering...

  459

  460         if (bd.Nom.HasDuplicates())

  461         {

  462           // Ask how to fix the duplicates

  463

  464           PromptKeywordOptions pko =

  465             new PromptKeywordOptions(

  466               "Blocks contain duplicate numbers. " +

  467               "How do you want to renumber?"

  468             );

  469           pko.AllowNone = true;

  470           pko.Keywords.Add("Automatically");

  471           pko.Keywords.Add("Individually");

  472           pko.Keywords.Add("Not");

  473           pko.Keywords.Default = "Automatically";

  474

  475           PromptResult pkr =

  476             ed.GetKeywords(pko);

  477

  478           bool bAuto = false;

  479           bool bManual = false;

  480

  481           if (pkr.Status != PromptStatus.OK)

  482             bd.Reset();

  483           else

  484           {

  485             if (pkr.StringResult == "Automatically")

  486               bAuto = true;

  487             else if (pkr.StringResult == "Individually")

  488               bManual = true;

  489

  490             // Whether fixing automatically or manually

  491             // we will iterate through the duplicate list

  492

  493             if (bAuto || bManual)

  494             {

  495               ObjectIdCollection idc =

  496                 new ObjectIdCollection();

  497

  498               // Get each entry in the duplicate list

  499

  500               SortedDictionary<int,List<ObjectId>> dups =

  501                 bd.Nom.Duplicates;

  502               foreach (

  503                 KeyValuePair<int,List<ObjectId>> dup in dups

  504               )

  505               {

  506                 // The position is the key in the entry

  507                 // and the list of IDs is the value

  508                 // (we take a copy, so we can modify it

  509                 // without affecting the original)

  510

  511                 int pos = dup.Key;

  512                 List<ObjectId> ids =

  513                   new List<ObjectId>(dup.Value);

  514

  515                 // For automatic renumbering there's no

  516                 // user interaction

  517

  518                 if (bAuto)

  519                 {

  520                   foreach (ObjectId id in ids)

  521                   {

  522                     bd.Nom.NextObjectNumber(id);

  523                     idc.Add(id);

  524                   }

  525                 }

  526                 else // bManual

  527                 {

  528                   // For manual renumbering we ask the user

  529                   // to select the block to keep, then

  530                   // we renumber the rest automatically

  531

  532                   ed.UpdateScreen();

  533

  534                   ids.Add(bd.Nom.GetObjectId(pos));

  535                   HighlightBubbles(db, ids, true);

  536

  537                   ed.WriteMessage(

  538                     "\n\nHighlighted blocks " +

  539                     "with number {0}. ",

  540                     pos + bd.BaseNumber

  541                   );

  542

  543                   bool finished = false;

  544                   while (!finished)

  545                   {

  546                     PromptEntityOptions peo =

  547                       new PromptEntityOptions(

  548                         "Select block to keep (others " +

  549                         "will be renumbered automatically): "

  550                       );

  551                     peo.SetRejectMessage(

  552                       "\nEntity must be a block."

  553                     );

  554                     peo.AddAllowedClass(

  555                       typeof(BlockReference), false);

  556                     PromptEntityResult per =

  557                       ed.GetEntity(peo);

  558

  559                     if (per.Status != PromptStatus.OK)

  560                     {

  561                       bd.Reset();

  562                       return;

  563                     }

  564                     else

  565                     {

  566                       // A block has been selected, so we

  567                       // make sure it is one of the ones

  568                       // we highlighted for the user

  569

  570                       if (ids.Contains(per.ObjectId))

  571                       {

  572                         // Leave the selected block alone

  573                         // by removing it from the list

  574

  575                         ids.Remove(per.ObjectId);

  576

  577                         // We then renumber each block in

  578                         // the list

  579

  580                         foreach (ObjectId id in ids)

  581                         {

  582                           bd.Nom.NextObjectNumber(id);

  583                           idc.Add(id);

  584                         }

  585                         RenumberBubbles(db, idc);

  586                         idc.Clear();

  587

  588                         // Let's unhighlight our selected

  589                         // block (renumbering will do this

  590                         // for the others)

  591

  592                         List<ObjectId> redraw =

  593                           new List<ObjectId>(1);

  594                         redraw.Add(per.ObjectId);

  595                         HighlightBubbles(db, redraw, false);

  596

  597                         finished = true;

  598                       }

  599                       else

  600                       {

  601                         ed.WriteMessage(

  602                           "\nBlock selected is not " +

  603                           "numbered with {0}. ",

  604                           pos + bd.BaseNumber

  605                         );

  606                       }

  607                     }

  608                   }

  609                 }

  610               }

  611               RenumberBubbles(db, idc);

  612             }

  613             bd.Nom.Duplicates.Clear();

  614             ed.UpdateScreen();

  615           }

  616         }

  617       }

  618     }

  619

  620     // Take a list of objects and either highlight

  621     // or unhighlight them, depending on the flag

  622

  623     private void HighlightBubbles(

  624       Database db, List<ObjectId> ids, bool highlight)

  625     {

  626       Transaction tr =

  627         db.TransactionManager.StartTransaction();

  628       using (tr)

  629       {

  630         foreach (ObjectId id in ids)

  631         {

  632           Entity ent =

  633             (Entity)tr.GetObject(

  634               id,

  635               OpenMode.ForRead

  636             );

  637           if (highlight)

  638             ent.Highlight();

  639           else

  640             ent.Draw();

  641         }

  642         tr.Commit();

  643       }

  644     }

  645

  646     // Command to create bubbles at points selected

  647     // by the user - loops until cancelled

  648

  649     [CommandMethod("BAP")]

  650     public void BubblesAtPoints()

  651     {

  652       Document doc =

  653         Application.DocumentManager.MdiActiveDocument;

  654       Database db = doc.Database;

  655       Editor ed = doc.Editor;

  656       Autodesk.AutoCAD.ApplicationServices.

  657       TransactionManager tm =

  658         doc.TransactionManager;

  659

  660       Transaction tr =

  661         tm.StartTransaction();

  662       using (tr)

  663       {

  664         // Get the information about the block

  665         // and attribute definitions we care about

  666

  667         BlockTableRecord ms;

  668         ObjectId blockId;

  669         AttributeDefinition ad;

  670         List<AttributeDefinition> other;

  671

  672         if (GetBlock(

  673               db, tr, out ms, out blockId

  674           ))

  675         {

  676           GetBlockAttributes(

  677             tr, blockId, out ad, out other

  678           );

  679

  680           // By default the modelspace is returned to

  681           // us in read-only state

  682

  683           ms.UpgradeOpen();

  684

  685           // Loop until cancelled

  686

  687           bool finished = false;

  688           while (!finished)

  689           {

  690             PromptPointOptions ppo =

  691               new PromptPointOptions("\nSelect point: ");

  692             ppo.AllowNone = true;

  693

  694             PromptPointResult ppr =

  695               ed.GetPoint(ppo);

  696             if (ppr.Status != PromptStatus.OK)

  697               finished = true;

  698             else

  699               // Call a function to create our bubble

  700               CreateNumberedBubbleAtPoint(

  701                 db, ms, tr, ppr.Value,

  702                 blockId, ad, other

  703               );

  704             tm.QueueForGraphicsFlush();

  705             tm.FlushGraphics();

  706           }

  707         }

  708         tr.Commit();

  709       }

  710     }

  711

  712     // Command to create a bubble at the center of

  713     // each of the selected circles

  714

  715     [CommandMethod("BIC")]

  716     public void BubblesInCircles()

  717     {

  718       Document doc =

  719         Application.DocumentManager.MdiActiveDocument;

  720       Database db = doc.Database;

  721       Editor ed = doc.Editor;

  722

  723       // Allow the user to select circles

  724

  725       TypedValue[] tvs =

  726         new TypedValue[1] {

  727             new TypedValue(

  728               (int)DxfCode.Start,

  729               "CIRCLE"

  730             )

  731           };

  732       SelectionFilter sf =

  733         new SelectionFilter(tvs);

  734

  735       PromptSelectionResult psr =

  736         ed.GetSelection(sf);

  737

  738       if (psr.Status == PromptStatus.OK &&

  739           psr.Value.Count > 0)

  740       {

  741         Transaction tr =

  742           db.TransactionManager.StartTransaction();

  743         using (tr)

  744         {

  745           // Get the information about the block

  746           // and attribute definitions we care about

  747

  748           BlockTableRecord ms;

  749           ObjectId blockId;

  750           AttributeDefinition ad;

  751           List<AttributeDefinition> other;

  752

  753           if (GetBlock(

  754                 db, tr, out ms, out blockId

  755             ))

  756           {

  757             GetBlockAttributes(

  758               tr, blockId, out ad, out other

  759             );

  760

  761             // By default the modelspace is returned to

  762             // us in read-only state

  763

  764             ms.UpgradeOpen();

  765

  766             foreach (SelectedObject o in psr.Value)

  767             {

  768               // For each circle in the selected list...

  769

  770               DBObject obj =

  771                 tr.GetObject(o.ObjectId, OpenMode.ForRead);

  772               Circle c = obj as Circle;

  773               if (c == null)

  774                 ed.WriteMessage(

  775                   "\nObject selected is not a circle."

  776                 );

  777               else

  778                 // Call our numbering function, passing the

  779                 // center of the circle

  780                 CreateNumberedBubbleAtPoint(

  781                   db, ms, tr, c.Center,

  782                   blockId, ad, other

  783                 );

  784             }

  785           }

  786           tr.Commit();

  787         }

  788       }

  789     }

  790

  791     // Command to delete a particular bubble

  792     // selected by its index

  793

  794     [CommandMethod("MB")]

  795     public void MoveBubble()

  796     {

  797       Document doc =

  798         Application.DocumentManager.MdiActiveDocument;

  799       Editor ed = doc.Editor;

  800       BubbleData bd =

  801         GetBubbleData(doc);

  802

  803       // Use a helper function to select a valid bubble index

  804

  805       int pos =

  806         GetBubbleNumber(

  807           ed, bd,

  808           "\nEnter number of bubble to move: "

  809         );

  810

  811       if (pos >= bd.BaseNumber)

  812       {

  813         int from = pos - bd.BaseNumber;

  814

  815         pos =

  816           GetBubbleNumber(

  817             ed, bd,

  818             "\nEnter destination position: "

  819           );

  820

  821         if (pos >= bd.BaseNumber)

  822         {

  823           int to = pos - bd.BaseNumber;

  824

  825           ObjectIdCollection ids =

  826             bd.Nom.MoveObject(from, to);

  827

  828           RenumberBubbles(doc.Database, ids);

  829         }

  830       }

  831     }

  832

  833     // Command to delete a particular bubbler,

  834     // selected by its index

  835

  836     [CommandMethod("DB")]

  837     public void DeleteBubble()

  838     {

  839       Document doc =

  840         Application.DocumentManager.MdiActiveDocument;

  841       Database db = doc.Database;

  842       Editor ed = doc.Editor;

  843       BubbleData bd =

  844         GetBubbleData(doc);

  845

  846       // Use a helper function to select a valid bubble index

  847

  848       int pos =

  849         GetBubbleNumber(

  850           ed, bd,

  851           "\nEnter number of bubble to erase: "

  852         );

  853

  854       if (pos >= bd.BaseNumber)

  855       {

  856         // Remove the object from the internal list

  857         // (this returns the ObjectId stored for it,

  858         // which we can then use to erase the entity)

  859

  860         ObjectId id =

  861           bd.Nom.RemoveObject(pos - bd.BaseNumber);

  862         Transaction tr =

  863           db.TransactionManager.StartTransaction();

  864         using (tr)

  865         {

  866           DBObject obj =

  867             tr.GetObject(id, OpenMode.ForWrite);

  868           obj.Erase();

  869           tr.Commit();

  870         }

  871       }

  872     }

  873

  874     // Command to reorder all the bubbles in the drawing,

  875     // closing all the gaps between numbers but maintaining

  876     // the current numbering order

  877

  878     [CommandMethod("RBS")]

  879     public void ReorderBubbles()

  880     {

  881       Document doc =

  882         Application.DocumentManager.MdiActiveDocument;

  883       BubbleData bd =

  884         GetBubbleData(doc);

  885

  886       // Re-order the bubbles - the IDs returned are

  887       // of the objects that need to be renumbered

  888

  889       ObjectIdCollection ids =

  890         bd.Nom.ReorderObjects();

  891

  892       RenumberBubbles(doc.Database, ids);

  893     }

  894

  895     // Command to highlight a particular bubble

  896

  897     [CommandMethod("HLB")]

  898     public void HighlightBubble()

  899     {

  900       Document doc =

  901         Application.DocumentManager.MdiActiveDocument;

  902       Database db = doc.Database;

  903       Editor ed = doc.Editor;

  904       BubbleData bd =

  905         GetBubbleData(doc);

  906

  907       // Use our function to select a valid bubble index

  908

  909       int pos =

  910         GetBubbleNumber(

  911           ed, bd,

  912           "\nEnter number of bubble to highlight: "

  913         );

  914

  915       if (pos >= bd.BaseNumber)

  916       {

  917         ObjectId id =

  918           bd.Nom.GetObjectId(pos - bd.BaseNumber);

  919

  920         if (id == ObjectId.Null)

  921         {

  922           ed.WriteMessage(

  923             "\nNumber is not currently used -" +

  924             " nothing to highlight."

  925           );

  926           return;

  927         }

  928         List<ObjectId> ids =

  929           new List<ObjectId>(1);

  930         ids.Add(id);

  931         HighlightBubbles(db, ids, true);

  932       }

  933     }

  934

  935     // Internal helper function to open and retrieve

  936     // the model-space and the block def we care about

  937

  938     private bool

  939       GetBlock(

  940         Database db,

  941         Transaction tr,

  942         out BlockTableRecord ms,

  943         out ObjectId blockId

  944       )

  945     {

  946       BlockTable bt =

  947         (BlockTable)tr.GetObject(

  948           db.BlockTableId,

  949           OpenMode.ForRead

  950         );

  951

  952       if (!bt.Has(blockName))

  953       {

  954         Document doc =

  955           Application.DocumentManager.MdiActiveDocument;

  956         Editor ed = doc.Editor;

  957         ed.WriteMessage(

  958           "\nCannot find block definition \"" +

  959           blockName +

  960           "\" in the current drawing."

  961         );

  962

  963         blockId = ObjectId.Null;

  964         ms = null;

  965         return false;

  966       }

  967

  968       ms =

  969         (BlockTableRecord)tr.GetObject(

  970           bt[BlockTableRecord.ModelSpace],

  971           OpenMode.ForRead

  972         );

  973

  974       blockId = bt[blockName];

  975

  976       return true;

  977     }

  978

  979     // Internal helper function to retrieve

  980     // attribute info from our block

  981     // (we return the main attribute def

  982     // and then all the "others")

  983

  984     private void

  985       GetBlockAttributes(

  986         Transaction tr,

  987         ObjectId blockId,

  988         out AttributeDefinition ad,

  989         out List<AttributeDefinition> other

  990       )

  991     {

  992       BlockTableRecord blk =

  993         (BlockTableRecord)tr.GetObject(

  994           blockId,

  995           OpenMode.ForRead

  996         );

  997

  998       ad = null;

  999       other =

1000         new List<AttributeDefinition>();

1001

1002       foreach (ObjectId attId in blk)

1003       {

1004         DBObject obj =

1005           (DBObject)tr.GetObject(

1006             attId,

1007             OpenMode.ForRead

1008           );

1009         AttributeDefinition ad2 =

1010           obj as AttributeDefinition;

1011

1012         if (ad2 != null)

1013         {

1014           if (ad2.Tag == attbName)

1015           {

1016             if (ad2.Constant)

1017             {

1018               Document doc =

1019                 Application.DocumentManager.MdiActiveDocument;

1020               Editor ed = doc.Editor;

1021

1022               ed.WriteMessage(

1023                 "\nAttribute to change is constant!"

1024               );

1025             }

1026             else

1027               ad = ad2;

1028           }

1029           else

1030             if (!ad2.Constant)

1031               other.Add(ad2);

1032         }

1033       }

1034     }

1035

1036     // Internal helper function to create a bubble

1037     // at a particular point

1038

1039     private Entity

1040       CreateNumberedBubbleAtPoint(

1041         Database db,

1042         BlockTableRecord btr,

1043         Transaction tr,

1044         Point3d pt,

1045         ObjectId blockId,

1046         AttributeDefinition ad,

1047         List<AttributeDefinition> other

1048       )

1049     {

1050       BubbleData bd =

1051         GetBubbleData(db);

1052

1053       //  Create a new block reference

1054

1055       BlockReference br =

1056         new BlockReference(pt, blockId);

1057

1058       // Add it to the database

1059

1060       br.SetDatabaseDefaults();

1061       ObjectId blockRefId = btr.AppendEntity(br);

1062       tr.AddNewlyCreatedDBObject(br, true);

1063

1064       // Create an attribute reference for our main

1065       // attribute definition (where we'll put the

1066       // bubble's number)

1067

1068       AttributeReference ar =

1069         new AttributeReference();

1070

1071       // Add it to the database, and set its position, etc.

1072

1073       ar.SetDatabaseDefaults();

1074       ar.SetAttributeFromBlock(ad, br.BlockTransform);

1075       ar.Position =

1076         ad.Position.TransformBy(br.BlockTransform);

1077       ar.Tag = ad.Tag;

1078

1079       // Set the bubble's number

1080

1081       int bubbleNumber =

1082         bd.BaseNumber +

1083         bd.Nom.NextObjectNumber(blockRefId);

1084

1085       ar.TextString = bubbleNumber.ToString();

1086       ar.AdjustAlignment(db);

1087

1088       // Add the attribute to the block reference

1089

1090       br.AttributeCollection.AppendAttribute(ar);

1091       tr.AddNewlyCreatedDBObject(ar, true);

1092

1093       // Now we add attribute references for the

1094       // other attribute definitions

1095

1096       foreach (AttributeDefinition ad2 in other)

1097       {

1098         AttributeReference ar2 =

1099           new AttributeReference();

1100

1101         ar2.SetAttributeFromBlock(ad2, br.BlockTransform);

1102         ar2.Position =

1103           ad2.Position.TransformBy(br.BlockTransform);

1104         ar2.Tag = ad2.Tag;

1105         ar2.TextString = ad2.TextString;

1106         ar2.AdjustAlignment(db);

1107

1108         br.AttributeCollection.AppendAttribute(ar2);

1109         tr.AddNewlyCreatedDBObject(ar2, true);

1110       }

1111       return br;

1112     }

1113

1114     // Internal helper function to have the user

1115     // select a valid bubble index

1116

1117     private int

1118       GetBubbleNumber(

1119         Editor ed,

1120         BubbleData bd,

1121         string prompt

1122       )

1123     {

1124       int upper = bd.Nom.GetUpperBound();

1125       if (upper <= 0)

1126       {

1127         ed.WriteMessage(

1128           "\nNo bubbles are currently being managed."

1129         );

1130         return upper;

1131       }

1132

1133       PromptIntegerOptions pio =

1134         new PromptIntegerOptions(prompt);

1135       pio.AllowNone = false;

1136

1137       // Get the limits from our manager object

1138

1139       pio.LowerLimit =

1140         bd.BaseNumber +

1141         bd.Nom.GetLowerBound(false);

1142       pio.UpperLimit =

1143         bd.BaseNumber +

1144         upper;

1145

1146       PromptIntegerResult pir =

1147         ed.GetInteger(pio);

1148       if (pir.Status == PromptStatus.OK)

1149         return pir.Value;

1150       else

1151         return -1;

1152     }

1153

1154     // Internal helper function to open up a list

1155     // of bubbles and reset their number to the

1156     // position in the list

1157

1158     private void RenumberBubbles(

1159       Database db, ObjectIdCollection ids)

1160     {

1161       BubbleData bd =

1162         GetBubbleData(db);

1163       Transaction tr =

1164         db.TransactionManager.StartTransaction();

1165       using (tr)

1166       {

1167         // Get the block information

1168

1169         BlockTableRecord ms;

1170         ObjectId blockId;

1171

1172         if (GetBlock(

1173               db, tr, out ms, out blockId

1174           ))

1175         {

1176           // Open each bubble to be renumbered

1177

1178           foreach (ObjectId bid in ids)

1179           {

1180             if (bid != ObjectId.Null)

1181             {

1182               DBObject obj =

1183                 tr.GetObject(bid, OpenMode.ForRead);

1184               BlockReference br = obj as BlockReference;

1185               if (br != null)

1186               {

1187                 if (br.BlockTableRecord == blockId)

1188                 {

1189                   AttributeCollection ac =

1190                     br.AttributeCollection;

1191

1192                   // Go through its attributes

1193

1194                   foreach (ObjectId aid in ac)

1195                   {

1196                     DBObject obj2 =

1197                       tr.GetObject(aid, OpenMode.ForRead);

1198                     AttributeReference ar =

1199                       obj2 as AttributeReference;

1200

1201                     if (ar.Tag == attbName)

1202                     {

1203                       // Change the one we care about

1204

1205                       ar.UpgradeOpen();

1206

1207                       int bubbleNumber =

1208                         bd.BaseNumber +

1209                         bd.Nom.GetNumber(bid);

1210                       ar.TextString =

1211                         bubbleNumber.ToString();

1212

1213                       break;

1214                     }

1215                   }

1216                 }

1217               }

1218             }

1219           }

1220         }

1221         tr.Commit();

1222       }

1223     }

1224   }

1225

1226   // A generic class for managing groups of

1227   // numbered (and ordered) objects

1228

1229   public class NumberedObjectManager

1230   {

1231     // Store the IDs of the objects we're managing

1232

1233     private List<ObjectId> m_ids;

1234

1235     // A list of free positions in the above list

1236     // (allows numbering gaps)

1237

1238     private List<int> m_free;

1239

1240     // A map of duplicates - blocks detected with

1241     // the number of an existing block

1242

1243     private SortedDictionary<int,List<ObjectId>> m_dups;

1244     public SortedDictionary<int, List<ObjectId>> Duplicates

1245     {

1246       get { return m_dups; }

1247     }

1248

1249     // Constructor

1250

1251     public NumberedObjectManager()

1252     {

1253       m_ids =

1254         new List<ObjectId>();

1255

1256       m_free =

1257         new List<int>();

1258

1259       m_dups =

1260         new SortedDictionary<int, List<ObjectId>>();

1261     }

1262

1263     // Clear the internal lists

1264

1265     public void Clear()

1266     {

1267       m_ids.Clear();

1268       m_free.Clear();

1269       m_dups.Clear();

1270     }

1271

1272     // Does the duplicate list contain anything?

1273

1274     public bool HasDuplicates()

1275     {

1276       return m_dups.Count > 0;

1277     }

1278

1279     // Return the first entry in the ObjectId list

1280     // (specify "true" if you want to skip

1281     // any null object IDs)

1282

1283     public int GetLowerBound(bool ignoreNull)

1284     {

1285       if (ignoreNull)

1286         // Define an in-line predicate to check

1287         // whether an ObjectId is null

1288         return

1289           m_ids.FindIndex(

1290             delegate(ObjectId id)

1291             {

1292               return id != ObjectId.Null;

1293             }

1294           );

1295       else

1296         return 0;

1297     }

1298

1299     // Return the last entry in the ObjectId list

1300

1301     public int GetUpperBound()

1302     {

1303       return m_ids.Count - 1;

1304     }

1305

1306     // Store the specified ObjectId in the next

1307     // available location in the list, and return

1308     // what that is

1309

1310     public int NextObjectNumber(ObjectId id)

1311     {

1312       int pos;

1313       if (m_free.Count > 0)

1314       {

1315         // Get the first free position, then remove

1316         // it from the "free" list

1317

1318         pos = m_free[0];

1319         m_free.RemoveAt(0);

1320         m_ids[pos] = id;

1321       }

1322       else

1323       {

1324         // There are no free slots (gaps in the numbering)

1325         // so we append it to the list

1326

1327         pos = m_ids.Count;

1328         m_ids.Add(id);

1329       }

1330       return pos;

1331     }

1332

1333     // Go through the list of objects and close any gaps

1334     // by shuffling the list down (easy, as we're using a

1335     // List<> rather than an array)

1336

1337     public ObjectIdCollection ReorderObjects()

1338     {

1339       // Create a collection of ObjectIds we'll return

1340       // for the caller to go and update

1341       // (so the renumbering will gets reflected

1342       // in the objects themselves)

1343

1344       ObjectIdCollection ids =

1345         new ObjectIdCollection();

1346

1347       // We'll go through the "free" list backwards,

1348       // to allow any changes made to the list of

1349       // objects to not affect what we're doing

1350

1351       List<int> rev =

1352         new List<int>(m_free);

1353       rev.Reverse();

1354

1355       foreach (int pos in rev)

1356       {

1357         // First we remove the object at the "free"

1358         // position (in theory this should be set to

1359         // ObjectId.Null, as the slot has been marked

1360         // as blank)

1361

1362         m_ids.RemoveAt(pos);

1363

1364         // Now we go through and add the IDs of any

1365         // affected objects to the list to return

1366

1367         for (int i = pos; i < m_ids.Count; i++)

1368         {

1369           ObjectId id = m_ids[pos];

1370

1371           // Only add non-null objects

1372           // not already in the list

1373

1374           if (!ids.Contains(id) &&

1375               id != ObjectId.Null)

1376             ids.Add(id);

1377         }

1378       }

1379

1380       // Our free slots have been filled, so clear

1381       // the list

1382

1383       m_free.Clear();

1384

1385       return ids;

1386     }

1387

1388     // Get the ID of an object at a particular position

1389

1390     public ObjectId GetObjectId(int pos)

1391     {

1392       if (pos < m_ids.Count)

1393         return m_ids[pos];

1394       else

1395         return ObjectId.Null;

1396     }

1397

1398     // Get the position of an ObjectId in the list

1399

1400     public int GetNumber(ObjectId id)

1401     {

1402       if (m_ids.Contains(id))

1403         return m_ids.IndexOf(id);

1404       else

1405         return -1;

1406     }

1407

1408     // Store an ObjectId in a particular position

1409     // (shuffle == true will "insert" it, shuffling

1410     // the remaining objects down,

1411     // shuffle == false will replace the item in

1412     // that slot)

1413

1414     public void NumberObject(

1415       ObjectId id, int index, bool shuffle, bool dups)

1416     {

1417       // If we're inserting into the list

1418

1419       if (index < m_ids.Count)

1420       {

1421         if (shuffle)

1422           // Insert takes care of the shuffling

1423           m_ids.Insert(index, id);

1424         else

1425         {

1426           // If we're replacing the existing item, do

1427           // so and then make sure the slot is removed

1428           // from the "free" list, if applicable

1429

1430           if (!dups ||

1431               m_ids[index] == ObjectId.Null)

1432           {

1433             m_ids[index] = id;

1434             if (m_free.Contains(index))

1435               m_free.Remove(index);

1436           }

1437           else

1438           {

1439             // If we're tracking duplicates, add our new

1440             // object to the duplicate list for that index

1441

1442             if (dups)

1443             {

1444               List<ObjectId> ids;

1445               if (m_dups.ContainsKey(index))

1446               {

1447                 ids = m_dups[index];

1448                 m_dups.Remove(index);

1449               }

1450               else

1451                 ids = new List<ObjectId>();

1452

1453               ids.Add(id);

1454               m_dups.Add(index, ids);

1455             }

1456           }

1457         }

1458       }

1459       else

1460       {

1461         // If we're appending, shuffling is irrelevant,

1462         // but we may need to add additional "free" slots

1463         // if the position comes after the end

1464

1465         while (m_ids.Count < index)

1466         {

1467           m_ids.Add(ObjectId.Null);

1468           m_free.Add(m_ids.LastIndexOf(ObjectId.Null));

1469           m_free.Sort();

1470         }

1471         m_ids.Add(id);

1472       }

1473     }

1474

1475     // Move an ObjectId already in the list to a

1476     // particular position

1477     // (ObjectIds between the two positions will

1478     // get shuffled down automatically)

1479

1480     public ObjectIdCollection MoveObject(

1481       int from, int to)

1482     {

1483       ObjectIdCollection ids =

1484         new ObjectIdCollection();

1485

1486       if (from < m_ids.Count &&

1487           to < m_ids.Count)

1488       {

1489         if (from != to)

1490         {

1491           ObjectId id = m_ids[from];

1492           m_ids.RemoveAt(from);

1493           m_ids.Insert(to, id);

1494

1495           int start = (from < to ? from : to);

1496           int end = (from < to ? to : from);

1497

1498           for (int i = start; i <= end; i++)

1499           {

1500             ids.Add(m_ids[i]);

1501           }

1502         }

1503         // Now need to adjust/recreate "free" list

1504         m_free.Clear();

1505         for (int j = 0; j < m_ids.Count; j++)

1506         {

1507           if (m_ids[j] == ObjectId.Null)

1508             m_free.Add(j);

1509         }

1510       }

1511       return ids;

1512     }

1513

1514     // Remove an ObjectId from the list

1515

1516     public int RemoveObject(ObjectId id)

1517     {

1518       // Check it's non-null and in the list

1519

1520       if (id != ObjectId.Null &&

1521           m_ids.Contains(id))

1522       {

1523         int pos = m_ids.IndexOf(id);

1524         RemoveObject(pos);

1525         return pos;

1526       }

1527       return -1;

1528     }

1529

1530     // Remove the ObjectId at a particular position

1531

1532     public ObjectId RemoveObject(int pos)

1533     {

1534       // Get the ObjectId in the specified position,

1535       // making sure it's non-null

1536

1537       ObjectId id = m_ids[pos];

1538       if (id != ObjectId.Null)

1539       {

1540         // Null out the position and add it to the

1541         // "free" list

1542

1543         m_ids[pos] = ObjectId.Null;

1544         m_free.Add(pos);

1545         m_free.Sort();

1546       }

1547       return id;

1548     }

1549

1550     // Dump out the object list information

1551     // as well as the "free" slots

1552

1553     public void DumpInfo(Editor ed)

1554     {

1555       if (m_ids.Count > 0)

1556       {

1557         ed.WriteMessage("\nIdx ObjectId");

1558

1559         int index = 0;

1560         foreach (ObjectId id in m_ids)

1561           ed.WriteMessage("\n{0} {1}", index++, id);

1562       }

1563

1564       if (m_free.Count > 0)

1565       {

1566         ed.WriteMessage("\n\nFree list: ");

1567

1568         foreach (int pos in m_free)

1569           ed.WriteMessage("{0} ", pos);

1570       }

1571       if (HasDuplicates())

1572       {

1573         ed.WriteMessage("\n\nDuplicate list: ");

1574

1575         foreach (

1576           KeyValuePair<int, List<ObjectId>> dup

1577           in m_dups

1578         )

1579         {

1580           int pos = dup.Key;

1581           List<ObjectId> ids = dup.Value;

1582

1583           ed.WriteMessage("\n{0}    ", pos);

1584

1585           foreach (ObjectId id in ids)

1586           {

1587             ed.WriteMessage("{0} ", id);

1588           }

1589         }

1590       }

1591     }

1592

1593     // Remove the initial n items from the list

1594

1595     public void RebaseList(int start)

1596     {

1597       // First we remove the ObjectIds

1598

1599       for (int i=0; i < start; i++)

1600         m_ids.RemoveAt(0);

1601

1602       // Then we go through the "free" list...

1603

1604       int idx = 0;

1605       while (idx < m_free.Count)

1606       {

1607         if (m_free[idx] < start)

1608           // Remove any that refer to the slots

1609           // we've removed

1610           m_free.RemoveAt(idx);

1611         else

1612         {

1613           // Subtracting the number of slots

1614           // we've removed from the other items

1615           m_free[idx] -= start;

1616           idx++;

1617         }

1618       }

1619

1620       // The duplicate list is more tricky, as we store

1621       // our list of objects against the index

1622       // (we need to remove and re-add each entry)

1623

1624       if (HasDuplicates())

1625       {

1626         // First we get all the indeces (which we use

1627         // to iterate through the list)

1628

1629         SortedDictionary<int, List<ObjectId>>.

1630         KeyCollection kc =

1631           m_dups.Keys;

1632

1633         // Copy the KeyCollection into a list of ints,

1634         // to make it easier to iterate

1635         // (this also allows us to modify the m_dups

1636         // object while we're iterating)

1637

1638         List<int> idxs = new List<int>(kc.Count);

1639         foreach (int pos in kc)

1640           idxs.Add(pos);

1641

1642         foreach (int pos in idxs)

1643         {

1644           List<ObjectId> ids;

1645           m_dups.TryGetValue(pos, out ids);

1646

1647           if (m_dups.ContainsKey(pos - start))

1648             throw new Exception(

1649               ErrorStatus.DuplicateKey,

1650               "\nClash detected - " +

1651               "duplicate list may be corrupted."

1652             );

1653           else

1654           {

1655             // Remove the old entry and add the new one

1656

1657             m_dups.Remove(pos);

1658             m_dups.Add(pos - start, ids);

1659           }

1660         }

1661       }

1662     }

1663   }

1664 }

As for the specific changes...

Lines 19-71 encapsulate the information we need to store per-document, with lines 140-183 allowing retrieval of this data.

Line 102-130 and 185-289 add event handlers to the application. Note that we watch Database.ObjectAppended event to find when numbered objects are added to a drawing, but we do the actually work of renumbering the objects during DocumentCollection.DocumentLockWillChange - the safe place to do so.

A lot of the additional line changes are simply to access the new per-document data via the BubbleData class: 300-302, 316-317, 322, 402, 418, 452-453, 800-801, 811, 813, 821, 823, 826, 843-844, 854,861, 883-884, 890, 904-905, 915, 1050-1051, 1083-1084, 1124, 1140-1141, 1143, 1161-1162, 1208-1209.

Lines 458-616 add the ability to renumber bubbles while scanning the drawing, whether automatically (with no user intervention) or semi-automatically (allowing the user to choose a specific bubble not to renumber). This latter process uses a new HighlightBubbles() function (lines 620-644) to highlight a list of bubbles (it's generic, so could be called HighlightObjects(), thinking about it). This is then also used by the HLB command, replacing the previous implementation (lines 917-931).

We now pass the BubbleData class through to the GetBubbleNumber() function, in line 1120. This is then used in lines 807, 817, 850 & 911.

The NumberedObjectManager class has required infrastructure changes to support duplicates: 1240-1247, 1259-1260, 1269 & 1272-1277. We're using a SortedDictionary to maintain a list of ObjectIds per position. This is a standard "overflow" data structure, and is only added to when a duplicate is found.

DumpInfo() now displays duplicate data in the DMP command (lines 1571-1590).

RebaseList() has been changed to move entries in the duplicate list. This ended up being quite complicated, as we're mapping a list of objects against a position (the dictionary key) and so it's the key that changes when we move the list's base.

To try out this additional functionality, try this:

1. Open a drawing with a bunch of bubbles, or create new ones.
2. Copy & paste these bubbles one or more times, to seed the drawing with duplicate-numbered objects.
3. Load the application and run the LNS command to understand the numbers in the drawing. Try the different options for renumbering duplicates (Automatically, Individually or Not).
4. Next try copying and pasting again, once the numbering system is active, and see how the copied numbers are changed.
5. INSERT a few bubbles: new blocks will also be renumbered - even if the user selects a particular number via the attribute editing dialog - but that's somewhat inevitable with this approach.

OK - now that we're up at nearly 1700 lines of code, it's getting time to bring this series to a close... (or at least to stop including the entire code in each post. :-)

DevCamps 2008 - Customization and Application Development Conferences

Last year we held our first DevCamps for AEC and Manufacturing customers & partners. Following on from their success, this year's events are fast approaching: this year we've added Geospatial into the mix, and are holding DevCamps through the month of June.

Manufacturing DevCamp
June 11-13, 2008
Portland, Oregon

Architecture, Engineering & Construction DevCamp
June 16-18, 2008
Wakefield, Massachusetts (near Boston)

Geospatial DevCamp
June 25-27, 2008
San Rafael, California (near San Francisco)

This is really a good opportunity to meet and get to know members of my team (DevTech) and Autodesk's engineering teams, as well as getting first-rate information on how to develop with Autodesk APIs.

For more information and links to the respective registration pages, go to http://www.autodesk.com/devcamp2008.

An automatic numbering system for AutoCAD blocks using .NET - Part 3

In the last post we introduced some additional features to the original post in this series. In this post we take advantage of - and further extend - those features, by allowing deletion, movement and compaction of the numbered objects.

Here's the modified C# code, with changed/new lines in red, and here is the the updated source file:

    1 using Autodesk.AutoCAD.ApplicationServices;

    2 using Autodesk.AutoCAD.Runtime;

    3 using Autodesk.AutoCAD.DatabaseServices;

    4 using Autodesk.AutoCAD.EditorInput;

    5 using Autodesk.AutoCAD.Geometry;

    6 using System.Collections.Generic;

    7

    8 namespace AutoNumberedBubbles

    9 {

   10   public class Commands : IExtensionApplication

   11   {

   12     // Strings identifying the block

   13     // and the attribute name to use

   14

   15     const string blockName = "BUBBLE";

   16     const string attbName = "NUMBER";

   17

   18     // We will use a separate object to

   19     // manage our numbering, and maintain a

   20     // "base" index (the start of the list)

   21

   22     private NumberedObjectManager m_nom;

   23     private int m_baseNumber = 0;

   24

   25     // Constructor

   26

   27     public Commands()

   28     {

   29       m_nom = new NumberedObjectManager();

   30     }

   31

   32     // Functions called on initialization & termination

   33

   34     public void Initialize()

   35     {

   36       try

   37       {

   38         Document doc =

   39           Application.DocumentManager.MdiActiveDocument;

   40         Editor ed = doc.Editor;

   41

   42         ed.WriteMessage(

   43           "\nLNS  Load numbering settings by analyzing the current drawing" +

   44           "\nDMP  Print internal numbering information" +

   45           "\nBAP  Create bubbles at points" +

   46           "\nBIC  Create bubbles at the center of circles" +

   47           "\nMB   Move a bubble in the list" +

   48           "\nDB   Delete a bubble" +

   49           "\nRBS  Reorder the bubbles, to close gaps caused by deletion" +

   50           "\nHLB  Highlight a particular bubble"

   51         );

   52       }

   53       catch

   54       { }

   55     }

   56

   57     public void Terminate()

   58     {

   59     }

   60

   61     // Command to extract and display information

   62     // about the internal numbering

   63

   64     [CommandMethod("DMP")]

   65     public void DumpNumberingInformation()

   66     {

   67       Document doc =

   68         Application.DocumentManager.MdiActiveDocument;

   69       Editor ed = doc.Editor;

   70       m_nom.DumpInfo(ed);

   71     }

   72

   73     // Command to analyze the current document and

   74     // understand which indeces have been used and

   75     // which are currently free

   76

   77     [CommandMethod("LNS")]

   78     public void LoadNumberingSettings()

   79     {

   80       Document doc =

   81         Application.DocumentManager.MdiActiveDocument;

   82       Database db = doc.Database;

   83       Editor ed = doc.Editor;

   84

   85       // We need to clear any internal state

   86       // already collected

   87

   88       m_nom.Clear();

   89       m_baseNumber = 0;

   90

   91       // Select all the blocks in the current drawing

   92

   93       TypedValue[] tvs =

   94         new TypedValue[1] {

   95             new TypedValue(

   96               (int)DxfCode.Start,

   97               "INSERT"

   98             )

   99           };

  100       SelectionFilter sf =

  101         new SelectionFilter(tvs);

  102

  103       PromptSelectionResult psr =

  104         ed.SelectAll(sf);

  105

  106       // If it succeeded and we have some blocks...

  107

  108       if (psr.Status == PromptStatus.OK &&

  109           psr.Value.Count > 0)

  110       {

  111         Transaction tr =

  112           db.TransactionManager.StartTransaction();

  113         using (tr)

  114         {

  115           // First get the modelspace and the ID

  116           // of the block for which we're searching

  117

  118           BlockTableRecord ms;

  119           ObjectId blockId;

  120

  121           if (GetBlock(

  122                 db, tr, out ms, out blockId

  123             ))

  124           {

  125             // For each block reference in the drawing...

  126

  127             foreach (SelectedObject o in psr.Value)

  128             {

  129               DBObject obj =

  130                 tr.GetObject(o.ObjectId, OpenMode.ForRead);

  131               BlockReference br = obj as BlockReference;

  132               if (br != null)

  133               {

  134                 // If it's the one we care about...

  135

  136                 if (br.BlockTableRecord == blockId)

  137                 {

  138                   // Check its attribute references...

  139

  140                   int pos = -1;

  141                   AttributeCollection ac =

  142                     br.AttributeCollection;

  143

  144                   foreach (ObjectId id in ac)

  145                   {

  146                     DBObject obj2 =

  147                       tr.GetObject(id, OpenMode.ForRead);

  148                     AttributeReference ar =

  149                       obj2 as AttributeReference;

  150

  151                     // When we find the attribute

  152                     // we care about...

  153

  154                     if (ar.Tag == attbName)

  155                     {

  156                       try

  157                       {

  158                         // Attempt to extract the number from

  159                         // the text string property... use a

  160                         // try-catch block just in case it is

  161                         // non-numeric

  162

  163                         pos =

  164                           int.Parse(ar.TextString);

  165

  166                         // Add the object at the appropriate

  167                         // index

  168

  169                         m_nom.NumberObject(

  170                           o.ObjectId, pos, false

  171                         );

  172                       }

  173                       catch { }

  174                     }

  175                   }

  176                 }

  177               }

  178             }

  179           }

  180           tr.Commit();

  181         }

  182

  183         // Once we have analyzed all the block references...

  184

  185         int start = m_nom.GetLowerBound(true);

  186

  187         // If the first index is non-zero, ask the user if

  188         // they want to rebase the list to begin at the

  189         // current start position

  190

  191         if (start > 0)

  192         {

  193           ed.WriteMessage(

  194             "\nLowest index is {0}. ",

  195             start

  196           );

  197           PromptKeywordOptions pko =

  198             new PromptKeywordOptions(

  199               "Make this the start of the list?"

  200             );

  201           pko.AllowNone = true;

  202           pko.Keywords.Add("Yes");

  203           pko.Keywords.Add("No");

  204           pko.Keywords.Default = "Yes";

  205

  206           PromptResult pkr =

  207             ed.GetKeywords(pko);

  208

  209           if (pkr.Status == PromptStatus.OK)

  210           {

  211             if (pkr.StringResult == "Yes")

  212             {

  213               // We store our own base number

  214               // (the object used to manage objects

  215               // always uses zero-based indeces)

  216

  217               m_baseNumber = start;

  218               m_nom.RebaseList(m_baseNumber);

  219             }

  220           }

  221         }

  222       }

  223     }

  224

  225     // Command to create bubbles at points selected

  226     // by the user - loops until cancelled

  227

  228     [CommandMethod("BAP")]

  229     public void BubblesAtPoints()

  230     {

  231       Document doc =

  232         Application.DocumentManager.MdiActiveDocument;

  233       Database db = doc.Database;

  234       Editor ed = doc.Editor;

  235       Autodesk.AutoCAD.ApplicationServices.

  236       TransactionManager tm =

  237         doc.TransactionManager;

  238

  239       Transaction tr =

  240         tm.StartTransaction();

  241       using (tr)

  242       {

  243         // Get the information about the block

  244         // and attribute definitions we care about

  245

  246         BlockTableRecord ms;

  247         ObjectId blockId;

  248         AttributeDefinition ad;

  249         List<AttributeDefinition> other;

  250

  251         if (GetBlock(

  252               db, tr, out ms, out blockId

  253           ))

  254         {

  255           GetBlockAttributes(

  256             tr, blockId, out ad, out other

  257           );

  258

  259           // By default the modelspace is returned to

  260           // us in read-only state

  261

  262           ms.UpgradeOpen();

  263

  264           // Loop until cancelled

  265

  266           bool finished = false;

  267           while (!finished)

  268           {

  269             PromptPointOptions ppo =

  270               new PromptPointOptions("\nSelect point: ");

  271             ppo.AllowNone = true;

  272

  273             PromptPointResult ppr =

  274               ed.GetPoint(ppo);

  275             if (ppr.Status != PromptStatus.OK)

  276               finished = true;

  277             else

  278               // Call a function to create our bubble

  279               CreateNumberedBubbleAtPoint(

  280                 db, ms, tr, ppr.Value,

  281                 blockId, ad, other

  282               );

  283             tm.QueueForGraphicsFlush();

  284             tm.FlushGraphics();

  285           }

  286         }

  287         tr.Commit();

  288       }

  289     }

  290

  291     // Command to create a bubble at the center of

  292     // each of the selected circles

  293

  294     [CommandMethod("BIC")]

  295     public void BubblesInCircles()

  296     {

  297       Document doc =

  298         Application.DocumentManager.MdiActiveDocument;

  299       Database db = doc.Database;

  300       Editor ed = doc.Editor;

  301

  302       // Allow the user to select circles

  303

  304       TypedValue[] tvs =

  305         new TypedValue[1] {

  306             new TypedValue(

  307               (int)DxfCode.Start,

  308               "CIRCLE"

  309             )

  310           };

  311       SelectionFilter sf =

  312         new SelectionFilter(tvs);

  313

  314       PromptSelectionResult psr =

  315         ed.GetSelection(sf);

  316

  317       if (psr.Status == PromptStatus.OK &&

  318           psr.Value.Count > 0)

  319       {

  320         Transaction tr =

  321           db.TransactionManager.StartTransaction();

  322         using (tr)

  323         {

  324           // Get the information about the block

  325           // and attribute definitions we care about

  326

  327           BlockTableRecord ms;

  328           ObjectId blockId;

  329           AttributeDefinition ad;

  330           List<AttributeDefinition> other;

  331

  332           if (GetBlock(

  333                 db, tr, out ms, out blockId

  334             ))

  335           {

  336             GetBlockAttributes(

  337               tr, blockId, out ad, out other

  338             );

  339

  340             // By default the modelspace is returned to

  341             // us in read-only state

  342

  343             ms.UpgradeOpen();

  344

  345             foreach (SelectedObject o in psr.Value)

  346             {

  347               // For each circle in the selected list...

  348

  349               DBObject obj =

  350                 tr.GetObject(o.ObjectId, OpenMode.ForRead);

  351               Circle c = obj as Circle;

  352               if (c == null)

  353                 ed.WriteMessage(

  354                   "\nObject selected is not a circle."

  355                 );

  356               else

  357                 // Call our numbering function, passing the

  358                 // center of the circle

  359                 CreateNumberedBubbleAtPoint(

  360                   db, ms, tr, c.Center,

  361                   blockId, ad, other

  362                 );

  363             }

  364           }

  365           tr.Commit();

  366         }

  367       }

  368     }

  369

  370     // Command to delete a particular bubble

  371     // selected by its index

  372

  373     [CommandMethod("MB")]

  374     public void MoveBubble()

  375     {

  376       Document doc =

  377         Application.DocumentManager.MdiActiveDocument;

  378       Editor ed = doc.Editor;

  379

  380       // Use a helper function to select a valid bubble index

  381

  382       int pos =

  383         GetBubbleNumber(

  384           ed,

  385           "\nEnter number of bubble to move: "

  386         );

  387

  388       if (pos >= m_baseNumber)

  389       {

  390         int from = pos - m_baseNumber;

  391

  392         pos =

  393           GetBubbleNumber(

  394             ed,

  395             "\nEnter destination position: "

  396           );

  397

  398         if (pos >= m_baseNumber)

  399         {

  400           int to = pos - m_baseNumber;

  401

  402           ObjectIdCollection ids =

  403             m_nom.MoveObject(from, to);

  404

  405           RenumberBubbles(doc.Database, ids);

  406         }

  407       }

  408     }

  409

  410     // Command to delete a particular bubbler,

  411     // selected by its index

  412

  413     [CommandMethod("DB")]

  414     public void DeleteBubble()

  415     {

  416       Document doc =

  417         Application.DocumentManager.MdiActiveDocument;

  418       Database db = doc.Database;

  419       Editor ed = doc.Editor;

  420

  421       // Use a helper function to select a valid bubble index

  422

  423       int pos =

  424         GetBubbleNumber(

  425           ed,

  426           "\nEnter number of bubble to erase: "

  427         );

  428

  429       if (pos >= m_baseNumber)

  430       {

  431         // Remove the object from the internal list

  432         // (this returns the ObjectId stored for it,

  433         // which we can then use to erase the entity)

  434

  435         ObjectId id =

  436           m_nom.RemoveObject(pos - m_baseNumber);

  437         Transaction tr =

  438           db.TransactionManager.StartTransaction();

  439         using (tr)

  440         {

  441           DBObject obj =

  442             tr.GetObject(id, OpenMode.ForWrite);

  443           obj.Erase();

  444           tr.Commit();

  445         }

  446       }

  447     }

  448

  449     // Command to reorder all the bubbles in the drawing,

  450     // closing all the gaps between numbers but maintaining

  451     // the current numbering order

  452

  453     [CommandMethod("RBS")]

  454     public void ReorderBubbles()

  455     {

  456       Document doc =

  457         Application.DocumentManager.MdiActiveDocument;

  458

  459       // Re-order the bubbles - the IDs returned are

  460       // of the objects that need to be renumbered

  461

  462       ObjectIdCollection ids =

  463         m_nom.ReorderObjects();

  464

  465       RenumberBubbles(doc.Database, ids);

  466     }

  467

  468     // Command to highlight a particular bubble

  469

  470     [CommandMethod("HLB")]

  471     public void HighlightBubble()

  472     {

  473       Document doc =

  474         Application.DocumentManager.MdiActiveDocument;

  475       Database db = doc.Database;

  476       Editor ed = doc.Editor;

  477

  478       // Use our function to select a valid bubble index

  479

  480       int pos =

  481         GetBubbleNumber(

  482           ed,

  483           "\nEnter number of bubble to highlight: "

  484         );

  485

  486       if (pos >= m_baseNumber)

  487       {

  488         Transaction tr =

  489           db.TransactionManager.StartTransaction();

  490         using (tr)

  491         {

  492           // Get the ObjectId from the index...

  493

  494           ObjectId id =

  495             m_nom.GetObjectId(pos - m_baseNumber);

  496

  497           if (id == ObjectId.Null)

  498           {

  499             ed.WriteMessage(

  500               "\nNumber is not currently used -" +

  501               " nothing to highlight."

  502             );

  503             return;

  504           }

  505

  506           // And then open & highlight the entity

  507

  508           Entity ent =

  509             (Entity)tr.GetObject(

  510               id,

  511               OpenMode.ForRead

  512             );

  513           ent.Highlight();

  514           tr.Commit();

  515         }

  516       }

  517     }

  518

  519     // Internal helper function to open and retrieve

  520     // the model-space and the block def we care about

  521

  522     private bool

  523       GetBlock(

  524         Database db,

  525         Transaction tr,

  526         out BlockTableRecord ms,

  527         out ObjectId blockId

  528       )

  529     {

  530       BlockTable bt =

  531         (BlockTable)tr.GetObject(

  532           db.BlockTableId,

  533           OpenMode.ForRead

  534         );

  535

  536       if (!bt.Has(blockName))

  537       {

  538         Document doc =

  539           Application.DocumentManager.MdiActiveDocument;

  540         Editor ed = doc.Editor;

  541         ed.WriteMessage(

  542           "\nCannot find block definition \"" +

  543           blockName +

  544           "\" in the current drawing."

  545         );

  546

  547         blockId = ObjectId.Null;

  548         ms = null;

  549         return false;

  550       }

  551

  552       ms =

  553         (BlockTableRecord)tr.GetObject(

  554           bt[BlockTableRecord.ModelSpace],

  555           OpenMode.ForRead

  556         );

  557

  558       blockId = bt[blockName];

  559

  560       return true;

  561     }

  562

  563     // Internal helper function to retrieve

  564     // attribute info from our block

  565     // (we return the main attribute def

  566     // and then all the "others")

  567

  568     private void

  569       GetBlockAttributes(

  570         Transaction tr,

  571         ObjectId blockId,

  572         out AttributeDefinition ad,

  573         out List<AttributeDefinition> other

  574       )

  575     {

  576       BlockTableRecord blk =

  577         (BlockTableRecord)tr.GetObject(

  578           blockId,

  579           OpenMode.ForRead

  580         );

  581

  582       ad = null;

  583       other =

  584         new List<AttributeDefinition>();

  585

  586       foreach (ObjectId attId in blk)

  587       {

  588         DBObject obj =

  589           (DBObject)tr.GetObject(

  590             attId,

  591             OpenMode.ForRead

  592           );

  593         AttributeDefinition ad2 =

  594           obj as AttributeDefinition;

  595

  596         if (ad2 != null)

  597         {

  598           if (ad2.Tag == attbName)

  599           {

  600             if (ad2.Constant)

  601             {

  602               Document doc =

  603                 Application.DocumentManager.MdiActiveDocument;

  604               Editor ed = doc.Editor;

  605

  606               ed.WriteMessage(

  607                 "\nAttribute to change is constant!"

  608               );

  609             }

  610             else

  611               ad = ad2;

  612           }

  613           else

  614             if (!ad2.Constant)

  615               other.Add(ad2);

  616         }

  617       }

  618     }

  619

  620     // Internal helper function to create a bubble

  621     // at a particular point

  622

  623     private Entity

  624       CreateNumberedBubbleAtPoint(

  625         Database db,

  626         BlockTableRecord btr,

  627         Transaction tr,

  628         Point3d pt,

  629         ObjectId blockId,

  630         AttributeDefinition ad,

  631         List<AttributeDefinition> other

  632       )

  633     {

  634       //  Create a new block reference

  635

  636       BlockReference br =

  637         new BlockReference(pt, blockId);

  638

  639       // Add it to the database

  640

  641       br.SetDatabaseDefaults();

  642       ObjectId blockRefId = btr.AppendEntity(br);

  643       tr.AddNewlyCreatedDBObject(br, true);

  644

  645       // Create an attribute reference for our main

  646       // attribute definition (where we'll put the

  647       // bubble's number)

  648

  649       AttributeReference ar =

  650         new AttributeReference();

  651

  652       // Add it to the database, and set its position, etc.

  653

  654       ar.SetDatabaseDefaults();

  655       ar.SetAttributeFromBlock(ad, br.BlockTransform);

  656       ar.Position =

  657         ad.Position.TransformBy(br.BlockTransform);

  658       ar.Tag = ad.Tag;

  659

  660       // Set the bubble's number

  661

  662       int bubbleNumber =

  663         m_baseNumber +

  664         m_nom.NextObjectNumber(blockRefId);

  665

  666       ar.TextString = bubbleNumber.ToString();

  667       ar.AdjustAlignment(db);

  668

  669       // Add the attribute to the block reference

  670

  671       br.AttributeCollection.AppendAttribute(ar);

  672       tr.AddNewlyCreatedDBObject(ar, true);

  673

  674       // Now we add attribute references for the

  675       // other attribute definitions

  676

  677       foreach (AttributeDefinition ad2 in other)

  678       {

  679         AttributeReference ar2 =

  680           new AttributeReference();

  681

  682         ar2.SetAttributeFromBlock(ad2, br.BlockTransform);

  683         ar2.Position =

  684           ad2.Position.TransformBy(br.BlockTransform);

  685         ar2.Tag = ad2.Tag;

  686         ar2.TextString = ad2.TextString;

  687         ar2.AdjustAlignment(db);

  688

  689         br.AttributeCollection.AppendAttribute(ar2);

  690         tr.AddNewlyCreatedDBObject(ar2, true);

  691       }

  692       return br;

  693     }

  694

  695     // Internal helper function to have the user

  696     // select a valid bubble index

  697

  698     private int

  699       GetBubbleNumber(

  700         Editor ed,

  701         string prompt

  702       )

  703     {

  704       int upper = m_nom.GetUpperBound();

  705       if (upper <= 0)

  706       {

  707         ed.WriteMessage(

  708           "\nNo bubbles are currently being managed."

  709         );

  710         return upper;

  711       }

  712

  713       PromptIntegerOptions pio =

  714         new PromptIntegerOptions(prompt);

  715       pio.AllowNone = false;

  716

  717       // Get the limits from our manager object

  718

  719       pio.LowerLimit =

  720         m_baseNumber +

  721         m_nom.GetLowerBound(false);

  722       pio.UpperLimit =

  723         m_baseNumber +

  724         upper;

  725

  726       PromptIntegerResult pir =

  727         ed.GetInteger(pio);

  728       if (pir.Status == PromptStatus.OK)

  729         return pir.Value;

  730       else

  731         return -1;

  732     }

  733

  734     // Internal helper function to open up a list

  735     // of bubbles and reset their number to the

  736     // position in the list

  737

  738     private void RenumberBubbles(

  739       Database db, ObjectIdCollection ids)

  740     {

  741       Transaction tr =

  742         db.TransactionManager.StartTransaction();

  743       using (tr)

  744       {

  745         // Get the block information

  746

  747         BlockTableRecord ms;

  748         ObjectId blockId;

  749

  750         if (GetBlock(

  751               db, tr, out ms, out blockId

  752           ))

  753         {

  754           // Open each bubble to be renumbered

  755

  756           foreach (ObjectId bid in ids)

  757           {

  758             if (bid != ObjectId.Null)

  759             {

  760               DBObject obj =

  761                 tr.GetObject(bid, OpenMode.ForRead);

  762               BlockReference br = obj as BlockReference;

  763               if (br != null)

  764               {

  765                 if (br.BlockTableRecord == blockId)

  766                 {

  767                   AttributeCollection ac =

  768                     br.AttributeCollection;

  769

  770                   // Go through its attributes

  771

  772                   foreach (ObjectId aid in ac)

  773                   {

  774                     DBObject obj2 =

  775                       tr.GetObject(aid, OpenMode.ForRead);

  776                     AttributeReference ar =

  777                       obj2 as AttributeReference;

  778

  779                     if (ar.Tag == attbName)

  780                     {

  781                       // Change the one we care about

  782

  783                       ar.UpgradeOpen();

  784

  785                       int bubbleNumber =

  786                         m_baseNumber + m_nom.GetNumber(bid);

  787                       ar.TextString =

  788                         bubbleNumber.ToString();

  789

  790                       break;

  791                     }

  792                   }

  793                 }

  794               }

  795             }

  796           }

  797         }

  798         tr.Commit();

  799       }

  800     }

  801   }

  802

  803   // A generic class for managing groups of

  804   // numbered (and ordered) objects

  805

  806   public class NumberedObjectManager

  807   {

  808     // We need to store a list of object IDs, but

  809     // also a list of free positions in the list

  810     // (this allows numbering gaps)

  811

  812     private List<ObjectId> m_ids;

  813     private List<int> m_free;

  814

  815     // Constructor

  816

  817     public NumberedObjectManager()

  818     {

  819       m_ids =

  820         new List<ObjectId>();

  821

  822       m_free =

  823         new List<int>();

  824     }

  825

  826     // Clear the internal lists

  827

  828     public void Clear()

  829     {

  830       m_ids.Clear();

  831       m_free.Clear();

  832     }

  833

  834     // Return the first entry in the ObjectId list

  835     // (specify "true" if you want to skip

  836     // any null object IDs)

  837

  838     public int GetLowerBound(bool ignoreNull)

  839     {

  840       if (ignoreNull)

  841         // Define an in-line predicate to check

  842         // whether an ObjectId is null

  843         return

  844           m_ids.FindIndex(

  845             delegate(ObjectId id)

  846             {

  847               return id != ObjectId.Null;

  848             }

  849           );

  850       else

  851         return 0;

  852     }

  853

  854     // Return the last entry in the ObjectId list

  855

  856     public int GetUpperBound()

  857     {

  858       return m_ids.Count - 1;

  859     }

  860

  861     // Store the specified ObjectId in the next

  862     // available location in the list, and return

  863     // what that is

  864

  865     public int NextObjectNumber(ObjectId id)

  866     {

  867       int pos;

  868       if (m_free.Count > 0)

  869       {

  870         // Get the first free position, then remove

  871         // it from the "free" list

  872

  873         pos = m_free[0];

  874         m_free.RemoveAt(0);

  875         m_ids[pos] = id;

  876       }

  877       else

  878       {

  879         // There are no free slots (gaps in the numbering)

  880         // so we append it to the list

  881

  882         pos = m_ids.Count;

  883         m_ids.Add(id);

  884       }

  885       return pos;

  886     }

  887

  888     // Go through the list of objects and close any gaps

  889     // by shuffling the list down (easy, as we're using a

  890     // List<> rather than an array)

  891

  892     public ObjectIdCollection ReorderObjects()

  893     {

  894       // Create a collection of ObjectIds we'll return

  895       // for the caller to go and update

  896       // (so the renumbering will gets reflected

  897       // in the objects themselves)

  898

  899       ObjectIdCollection ids =

  900         new ObjectIdCollection();

  901

  902       // We'll go through the "free" list backwards,

  903       // to allow any changes made to the list of

  904       // objects to not affect what we're doing

  905

  906       List<int> rev =

  907         new List<int>(m_free);

  908       rev.Reverse();

  909

  910       foreach (int pos in rev)

  911       {

  912         // First we remove the object at the "free"

  913         // position (in theory this should be set to

  914         // ObjectId.Null, as the slot has been marked

  915         // as blank)

  916

  917         m_ids.RemoveAt(pos);

  918

  919         // Now we go through and add the IDs of any

  920         // affected objects to the list to return

  921

  922         for (int i = pos; i < m_ids.Count; i++)

  923         {

  924           ObjectId id = m_ids[pos];

  925

  926           // Only add non-null objects

  927           // not already in the list

  928

  929           if (!ids.Contains(id) &&

  930               id != ObjectId.Null)

  931             ids.Add(id);

  932         }

  933       }

  934

  935       // Our free slots have been filled, so clear

  936       // the list

  937

  938       m_free.Clear();

  939

  940       return ids;

  941     }

  942

  943     // Get the ID of an object at a particular position

  944

  945     public ObjectId GetObjectId(int pos)

  946     {

  947       if (pos < m_ids.Count)

  948         return m_ids[pos];

  949       else

  950         return ObjectId.Null;

  951     }

  952

  953     // Get the position of an ObjectId in the list

  954

  955     public int GetNumber(ObjectId id)

  956     {

  957       if (m_ids.Contains(id))

  958         return m_ids.IndexOf(id);

  959       else

  960         return -1;

  961     }

  962

  963     // Store an ObjectId in a particular position

  964     // (shuffle == true will "insert" it, shuffling

  965     // the remaining objects down,

  966     // shuffle == false will replace the item in

  967     // that slot)

  968

  969     public void NumberObject(

  970       ObjectId id, int index, bool shuffle)

  971     {

  972       // If we're inserting into the list

  973

  974       if (index < m_ids.Count)

  975       {

  976         if (shuffle)

  977           // Insert takes care of the shuffling

  978           m_ids.Insert(index, id);

  979         else

  980         {

  981           // If we're replacing the existing item, do

  982           // so and then make sure the slot is removed

  983           // from the "free" list, if applicable

  984

  985           m_ids[index] = id;

  986           if (m_free.Contains(index))

  987             m_free.Remove(index);

  988         }

  989       }

  990       else

  991       {

  992         // If we're appending, shuffling is irrelevant,

  993         // but we may need to add additional "free" slots

  994         // if the position comes after the end

  995

  996         while (m_ids.Count < index)

  997         {

  998           m_ids.Add(ObjectId.Null);

  999           m_free.Add(m_ids.LastIndexOf(ObjectId.Null));

1000           m_free.Sort();

1001         }

1002         m_ids.Add(id);

1003       }

1004     }

1005

1006     // Move an ObjectId already in the list to a

1007     // particular position

1008     // (ObjectIds between the two positions will

1009     // get shuffled down automatically)

1010

1011     public ObjectIdCollection MoveObject(

1012       int from, int to)

1013     {

1014       ObjectIdCollection ids =

1015         new ObjectIdCollection();

1016

1017       if (from < m_ids.Count &&

1018           to < m_ids.Count)

1019       {

1020         if (from != to)

1021         {

1022           ObjectId id = m_ids[from];

1023           m_ids.RemoveAt(from);

1024           m_ids.Insert(to, id);

1025

1026           int start = (from < to ? from : to);

1027           int end = (from < to ? to : from);

1028

1029           for (int i = start; i <= end; i++)

1030           {

1031             ids.Add(m_ids[i]);

1032           }

1033         }

1034         // Now need to adjust/recreate "free" list

1035         m_free.Clear();

1036         for (int j = 0; j < m_ids.Count; j++)

1037         {

1038           if (m_ids[j] == ObjectId.Null)

1039             m_free.Add(j);

1040         }

1041       }

1042       return ids;

1043     }

1044

1045     // Remove an ObjectId from the list

1046

1047     public int RemoveObject(ObjectId id)

1048     {

1049       // Check it's non-null and in the list

1050

1051       if (id != ObjectId.Null &&

1052           m_ids.Contains(id))

1053       {

1054         int pos = m_ids.IndexOf(id);

1055         RemoveObject(pos);

1056         return pos;

1057       }

1058       return -1;

1059     }

1060

1061     // Remove the ObjectId at a particular position

1062

1063     public ObjectId RemoveObject(int pos)

1064     {

1065       // Get the ObjectId in the specified position,

1066       // making sure it's non-null

1067

1068       ObjectId id = m_ids[pos];

1069       if (id != ObjectId.Null)

1070       {

1071         // Null out the position and add it to the

1072         // "free" list

1073

1074         m_ids[pos] = ObjectId.Null;

1075         m_free.Add(pos);

1076         m_free.Sort();

1077       }

1078       return id;

1079     }

1080

1081     // Dump out the object list information

1082     // as well as the "free" slots

1083

1084     public void DumpInfo(Editor ed)

1085     {

1086       if (m_ids.Count > 0)

1087       {

1088         ed.WriteMessage("\nIdx ObjectId");

1089

1090         int index = 0;

1091         foreach (ObjectId id in m_ids)

1092           ed.WriteMessage("\n{0} {1}", index++, id);

1093       }

1094

1095       if (m_free.Count > 0)

1096       {

1097         ed.WriteMessage("\n\nFree list: ");

1098

1099         foreach (int pos in m_free)

1100           ed.WriteMessage("{0} ", pos);

1101       }

1102     }

1103

1104     // Remove the initial n items from the list

1105

1106     public void RebaseList(int start)

1107     {

1108       // First we remove the ObjectIds

1109

1110       for (int i=0; i < start; i++)

1111         m_ids.RemoveAt(0);

1112

1113       // Then we go through the "free" list...

1114

1115       int idx = 0;

1116       while (idx < m_free.Count)

1117       {

1118         if (m_free[idx] < start)

1119           // Remove any that refer to the slots

1120           // we've removed

1121           m_free.RemoveAt(idx);

1122         else

1123         {

1124           // Subtracting the number of slots

1125           // we've removed from the other items

1126           m_free[idx] -= start;

1127           idx++;

1128         }

1129       }

1130     }

1131   }

1132 }

The above code defines four new commands which move, delete and highlight a bubble, and reorder the bubble list. I could probably have used better terminology for some of the command-names - the MB (Move Bubble) command does not move the physical position of the block in the drawing, it moves the bubble inside the list (i.e. it changes the bubble's number while maintaining the consistency of the list). Similarly, RBS (Reorder BubbleS) actually just compacts the list, removing unnecessary gaps in the list created by deletion. Anyway, the user is notified of the additional commands by lines 46-50, and the commands themselves are implemented by lines 370-517. MB, DB (Delete Bubble) and HLB (HighLight Bubble) all use a new helper function, GetBubbleNumber(), defined by lines 695-733, which asks the user to select a valid bubble from the list, which will then get moved, deleted or highlighted, as appropriate.

The other new helper function which is defined outside the NumberedObjectManager class (as the function depends on the specific implementation of our object numbering, i.e. with the value stored in an attribute in a block), is RenumberBubbles(), defined by lines 734-800. This function opens up a list of bubbles and sets their visible number to the one stored in the NamedObjectManager object. It is used by both MB and RBS.

To support these new commands, the NamedObjectManager class has also been extended in two new sections of the above code. The first new chunk of code (lines 888-961) implements new methods ReorderObjects() which again, is really a list compaction function and then GetObjectId() and GetNumber(), which - as you'd expect - return an ObjectId at a particular position and a position for a particular ObjectId. The next chunk (lines 1006-1079) implements MoveObject(), which moves an object from one place to another - shuffling the intermediate bubbles around, as needed - and two versions of RemoveObject(), depending on whether you wish to select the object by its ID or its position.

Something important to note about this implementation: so far we haven't dealt with what happens should the user choose to undo these commands: as the objects we're creating are not managed by AutoCAD (they are not stored in the drawing, for instance), their state is not captured in the undo filer, and so will not be affected by undo. But the geometry they refer to will, of course, so there is substantial potential for our list getting out of sync with reality. The easy (and arguably the best) way to get around this is to check for undo-related commands to be executed, and invalidate our list at that point (providing a suitable notification to the user, requesting that they run LNS again once done with their undoing & redoing). The current implementation does not do this.

Let's now take our new commands for a quick spin...

We're going to take our previously-created drawing, as a starting point, and use our new commands on it.

Let's start with DB:

Command: LNS

Lowest index is 1. Make this the start of the list? [Yes/No] <Yes>: Yes

Command: DB

Enter number of bubble to erase: 3

Command: DB

Enter number of bubble to erase: 5

Command: DB

Enter number of bubble to erase: 15

Command: DB

Enter number of bubble to erase: 16

Command: DMP

Idx ObjectId

0 (2129683752)

1 (2129683776)

2 (0)

3 (2129683824)

4 (0)

5 (2129683872)

6 (2129683896)

7 (2129683920)

8 (2129683944)

9 (2129683968)

10 (2129683992)

11 (2129684016)

12 (2129684040)

13 (2129684064)

14 (0)

15 (0)

16 (2129684136)

17 (2129684160)

18 (2129684184)

19 (2129684208)

Free list: 2 4 14 15

As you can see, we've ended up with a few free slots in our list (and you'll note you need to add our "base number" (1) to get to the visible number). Here's the state of the drawing at this point:

Now let's try MB:

Command: MB

Enter number of bubble to move: 7

Enter destination position: 2

Command: DMP

Idx ObjectId

0 (2129683752)

1 (2129683896)

2 (2129683776)

3 (0)

4 (2129683824)

5 (0)

6 (2129683872)

7 (2129683920)

8 (2129683944)

9 (2129683968)

10 (2129683992)

11 (2129684016)

12 (2129684040)

13 (2129684064)

14 (0)

15 (0)

16 (2129684136)

17 (2129684160)

18 (2129684184)

19 (2129684208)

Free list: 3 5 14 15

This results in the item in internal slot 6 being moved to internal slot 1 (remember that base number :-) and the objects between being shuffled along. Here's what's on the screen at this point:

And finally we'll compact the list - removing those four free slots - with our RBS command:

Command: RBS

Command: DMP

Idx ObjectId

0 (2129683752)

1 (2129683896)

2 (2129683776)

3 (2129683824)

4 (2129683872)

5 (2129683920)

6 (2129683944)

7 (2129683968)

8 (2129683992)

9 (2129684016)

10 (2129684040)

11 (2129684064)

12 (2129684136)

13 (2129684160)

14 (2129684184)

15 (2129684208)

And here's how that looks:

I don't currently have any further enhancements planned for this application. Feel free to post a comment or send me an email if there's a particular direction in which you'd like to see it go. For instance, is it interesting to see support for prefixes/suffixes...?

An automatic numbering system for AutoCAD blocks using .NET - Part 2

In the last post we saw some code to perform simple sequential numbering of blocks (reflected in a particular attribute contained in each block). In this next installment we'll extend the code by introducing a NumberedObjectManager class, which will manage the activities related to maintaining the sequence of numbers used by the various blocks. The main code will create an object of this class which will be used extensively in this and the next post by a number of new commands.

Here's the updated C# code, with changed & new lines marked with a red line-number. For your convenience here is the source file, to save you having to strip off the line numbers.

    1 using Autodesk.AutoCAD.ApplicationServices;

    2 using Autodesk.AutoCAD.Runtime;

    3 using Autodesk.AutoCAD.DatabaseServices;

    4 using Autodesk.AutoCAD.EditorInput;

    5 using Autodesk.AutoCAD.Geometry;

    6 using System.Collections.Generic;

    7

    8 namespace AutoNumberedBubbles

    9 {

   10   public class Commands : IExtensionApplication

   11   {

   12     // Strings identifying the block

   13     // and the attribute name to use

   14

   15     const string blockName = "BUBBLE";

   16     const string attbName = "NUMBER";

   17

   18     // We will use a separate object to

   19     // manage our numbering, and maintain a

   20     // "base" index (the start of the list)

   21

   22     private NumberedObjectManager m_nom;

   23     private int m_baseNumber = 0;

   24

   25     // Constructor

   26

   27     public Commands()

   28     {

   29       m_nom = new NumberedObjectManager();

   30     }

   31

   32     // Functions called on initialization & termination

   33

   34     public void Initialize()

   35     {

   36       try

   37       {

   38         Document doc =

   39           Application.DocumentManager.MdiActiveDocument;

   40         Editor ed = doc.Editor;

   41

   42         ed.WriteMessage(

   43           "\nLNS  Load numbering settings by analyzing the current drawing" +

   44           "\nDMP  Print internal numbering information" +

   45           "\nBAP  Create bubbles at points" +

   46           "\nBIC  Create bubbles at the center of circles"

   47         );

   48       }

   49       catch

   50       { }

   51     }

   52

   53     public void Terminate()

   54     {

   55     }

   56

   57     // Command to extract and display information

   58     // about the internal numbering

   59

   60     [CommandMethod("DMP")]

   61     public void DumpNumberingInformation()

   62     {

   63       Document doc =

   64         Application.DocumentManager.MdiActiveDocument;

   65       Editor ed = doc.Editor;

   66       m_nom.DumpInfo(ed);

   67     }

   68

   69     // Command to analyze the current document and

   70     // understand which indeces have been used and

   71     // which are currently free

   72

   73     [CommandMethod("LNS")]

   74     public void LoadNumberingSettings()

   75     {

   76       Document doc =

   77         Application.DocumentManager.MdiActiveDocument;

   78       Database db = doc.Database;

   79       Editor ed = doc.Editor;

   80

   81       // We need to clear any internal state

   82       // already collected

   83

   84       m_nom.Clear();

   85       m_baseNumber = 0;

   86

   87       // Select all the blocks in the current drawing

   88

   89       TypedValue[] tvs =

   90         new TypedValue[1] {

   91             new TypedValue(

   92               (int)DxfCode.Start,

   93               "INSERT"

   94             )

   95           };

   96       SelectionFilter sf =

   97         new SelectionFilter(tvs);

   98

   99       PromptSelectionResult psr =

  100         ed.SelectAll(sf);

  101

  102       // If it succeeded and we have some blocks...

  103

  104       if (psr.Status == PromptStatus.OK &&

  105           psr.Value.Count > 0)

  106       {

  107         Transaction tr =

  108           db.TransactionManager.StartTransaction();

  109         using (tr)

  110         {

  111           // First get the modelspace and the ID

  112           // of the block for which we're searching

  113

  114           BlockTableRecord ms;

  115           ObjectId blockId;

  116

  117           if (GetBlock(

  118                 db, tr, out ms, out blockId

  119             ))

  120           {

  121             // For each block reference in the drawing...

  122

  123             foreach (SelectedObject o in psr.Value)

  124             {

  125               DBObject obj =

  126                 tr.GetObject(o.ObjectId, OpenMode.ForRead);

  127               BlockReference br = obj as BlockReference;

  128               if (br != null)

  129               {

  130                 // If it's the one we care about...

  131

  132                 if (br.BlockTableRecord == blockId)

  133                 {

  134                   // Check its attribute references...

  135

  136                   int pos = -1;

  137                   AttributeCollection ac =

  138                     br.AttributeCollection;

  139

  140                   foreach (ObjectId id in ac)

  141                   {

  142                     DBObject obj2 =

  143                       tr.GetObject(id, OpenMode.ForRead);

  144                     AttributeReference ar =

  145                       obj2 as AttributeReference;

  146

  147                     // When we find the attribute

  148                     // we care about...

  149

  150                     if (ar.Tag == attbName)

  151                     {

  152                       try

  153                       {

  154                         // Attempt to extract the number from

  155                         // the text string property... use a

  156                         // try-catch block just in case it is

  157                         // non-numeric

  158

  159                         pos =

  160                           int.Parse(ar.TextString);

  161

  162                         // Add the object at the appropriate

  163                         // index

  164

  165                         m_nom.NumberObject(

  166                           o.ObjectId, pos, false

  167                         );

  168                       }

  169                       catch { }

  170                     }

  171                   }

  172                 }

  173               }

  174             }

  175           }

  176           tr.Commit();

  177         }

  178

  179         // Once we have analyzed all the block references...

  180

  181         int start = m_nom.GetLowerBound(true);

  182

  183         // If the first index is non-zero, ask the user if

  184         // they want to rebase the list to begin at the

  185         // current start position

  186

  187         if (start > 0)

  188         {

  189           ed.WriteMessage(

  190             "\nLowest index is {0}. ",

  191             start

  192           );

  193           PromptKeywordOptions pko =

  194             new PromptKeywordOptions(

  195               "Make this the start of the list?"

  196             );

  197           pko.AllowNone = true;

  198           pko.Keywords.Add("Yes");

  199           pko.Keywords.Add("No");

  200           pko.Keywords.Default = "Yes";

  201

  202           PromptResult pkr =

  203             ed.GetKeywords(pko);

  204

  205           if (pkr.Status == PromptStatus.OK)

  206           {

  207             if (pkr.StringResult == "Yes")

  208             {

  209               // We store our own base number

  210               // (the object used to manage objects

  211               // always uses zero-based indeces)

  212

  213               m_baseNumber = start;

  214               m_nom.RebaseList(m_baseNumber);

  215             }

  216           }

  217         }

  218       }

  219     }

  220

  221     // Command to create bubbles at points selected

  222     // by the user - loops until cancelled

  223

  224     [CommandMethod("BAP")]

  225     public void BubblesAtPoints()

  226     {

  227       Document doc =

  228         Application.DocumentManager.MdiActiveDocument;

  229       Database db = doc.Database;

  230       Editor ed = doc.Editor;

  231       Autodesk.AutoCAD.ApplicationServices.

  232       TransactionManager tm =

  233         doc.TransactionManager;

  234

  235       Transaction tr =

  236         tm.StartTransaction();

  237       using (tr)

  238       {

  239         // Get the information about the block

  240         // and attribute definitions we care about

  241

  242         BlockTableRecord ms;

  243         ObjectId blockId;

  244         AttributeDefinition ad;

  245         List<AttributeDefinition> other;

  246

  247         if (GetBlock(

  248               db, tr, out ms, out blockId

  249           ))

  250         {

  251           GetBlockAttributes(

  252             tr, blockId, out ad, out other

  253           );

  254

  255           // By default the modelspace is returned to

  256           // us in read-only state

  257

  258           ms.UpgradeOpen();

  259

  260           // Loop until cancelled

  261

  262           bool finished = false;

  263           while (!finished)

  264           {

  265             PromptPointOptions ppo =

  266               new PromptPointOptions("\nSelect point: ");

  267             ppo.AllowNone = true;

  268

  269             PromptPointResult ppr =

  270               ed.GetPoint(ppo);

  271             if (ppr.Status != PromptStatus.OK)

  272               finished = true;

  273             else

  274               // Call a function to create our bubble

  275               CreateNumberedBubbleAtPoint(

  276                 db, ms, tr, ppr.Value,

  277                 blockId, ad, other

  278               );

  279             tm.QueueForGraphicsFlush();

  280             tm.FlushGraphics();

  281           }

  282         }

  283         tr.Commit();

  284       }

  285     }

  286

  287     // Command to create a bubble at the center of

  288     // each of the selected circles

  289

  290     [CommandMethod("BIC")]

  291     public void BubblesInCircles()

  292     {

  293       Document doc =

  294         Application.DocumentManager.MdiActiveDocument;

  295       Database db = doc.Database;

  296       Editor ed = doc.Editor;

  297

  298       // Allow the user to select circles

  299

  300       TypedValue[] tvs =

  301         new TypedValue[1] {

  302             new TypedValue(

  303               (int)DxfCode.Start,

  304               "CIRCLE"

  305             )

  306           };

  307       SelectionFilter sf =

  308         new SelectionFilter(tvs);

  309

  310       PromptSelectionResult psr =

  311         ed.GetSelection(sf);

  312

  313       if (psr.Status == PromptStatus.OK &&

  314           psr.Value.Count > 0)

  315       {

  316         Transaction tr =

  317           db.TransactionManager.StartTransaction();

  318         using (tr)

  319         {

  320           // Get the information about the block

  321           // and attribute definitions we care about

  322

  323           BlockTableRecord ms;

  324           ObjectId blockId;

  325           AttributeDefinition ad;

  326           List<AttributeDefinition> other;

  327

  328           if (GetBlock(

  329                 db, tr, out ms, out blockId

  330             ))

  331           {

  332             GetBlockAttributes(

  333               tr, blockId, out ad, out other

  334             );

  335

  336             // By default the modelspace is returned to

  337             // us in read-only state

  338

  339             ms.UpgradeOpen();

  340

  341             foreach (SelectedObject o in psr.Value)

  342             {

  343               // For each circle in the selected list...

  344

  345               DBObject obj =

  346                 tr.GetObject(o.ObjectId, OpenMode.ForRead);

  347               Circle c = obj as Circle;

  348               if (c == null)

  349                 ed.WriteMessage(

  350                   "\nObject selected is not a circle."

  351                 );

  352               else

  353                 // Call our numbering function, passing the

  354                 // center of the circle

  355                 CreateNumberedBubbleAtPoint(

  356                   db, ms, tr, c.Center,

  357                   blockId, ad, other

  358                 );

  359             }

  360           }

  361           tr.Commit();

  362         }

  363       }

  364     }

  365

  366     // Internal helper function to open and retrieve

  367     // the model-space and the block def we care about

  368

  369     private bool

  370       GetBlock(

  371         Database db,

  372         Transaction tr,

  373         out BlockTableRecord ms,

  374         out ObjectId blockId

  375       )

  376     {

  377       BlockTable bt =

  378         (BlockTable)tr.GetObject(

  379           db.BlockTableId,

  380           OpenMode.ForRead

  381         );

  382

  383       if (!bt.Has(blockName))

  384       {

  385         Document doc =

  386           Application.DocumentManager.MdiActiveDocument;

  387         Editor ed = doc.Editor;

  388         ed.WriteMessage(

  389           "\nCannot find block definition \"" +

  390           blockName +

  391           "\" in the current drawing."

  392         );

  393

  394         blockId = ObjectId.Null;

  395         ms = null;

  396         return false;

  397       }

  398

  399       ms =

  400         (BlockTableRecord)tr.GetObject(

  401           bt[BlockTableRecord.ModelSpace],

  402           OpenMode.ForRead

  403         );

  404

  405       blockId = bt[blockName];

  406

  407       return true;

  408     }

  409

  410     // Internal helper function to retrieve

  411     // attribute info from our block

  412     // (we return the main attribute def

  413     // and then all the "others")

  414

  415     private void

  416       GetBlockAttributes(

  417         Transaction tr,

  418         ObjectId blockId,

  419         out AttributeDefinition ad,

  420         out List<AttributeDefinition> other

  421       )

  422     {

  423       BlockTableRecord blk =

  424         (BlockTableRecord)tr.GetObject(

  425           blockId,

  426           OpenMode.ForRead

  427         );

  428

  429       ad = null;

  430       other =

  431         new List<AttributeDefinition>();

  432

  433       foreach (ObjectId attId in blk)

  434       {

  435         DBObject obj =

  436           (DBObject)tr.GetObject(

  437             attId,

  438             OpenMode.ForRead

  439           );

  440         AttributeDefinition ad2 =

  441           obj as AttributeDefinition;

  442

  443         if (ad2 != null)

  444         {

  445           if (ad2.Tag == attbName)

  446           {

  447             if (ad2.Constant)

  448             {

  449               Document doc =

  450                 Application.DocumentManager.MdiActiveDocument;

  451               Editor ed = doc.Editor;

  452

  453               ed.WriteMessage(

  454                 "\nAttribute to change is constant!"

  455               );

  456             }

  457             else

  458               ad = ad2;

  459           }

  460           else

  461             if (!ad2.Constant)

  462               other.Add(ad2);

  463         }

  464       }

  465     }

  466

  467     // Internal helper function to create a bubble

  468     // at a particular point

  469

  470     private Entity

  471       CreateNumberedBubbleAtPoint(

  472         Database db,

  473         BlockTableRecord btr,

  474         Transaction tr,

  475         Point3d pt,

  476         ObjectId blockId,

  477         AttributeDefinition ad,

  478         List<AttributeDefinition> other

  479       )

  480     {

  481       //  Create a new block reference

  482

  483       BlockReference br =

  484         new BlockReference(pt, blockId);

  485

  486       // Add it to the database

  487

  488       br.SetDatabaseDefaults();

  489       ObjectId blockRefId = btr.AppendEntity(br);

  490       tr.AddNewlyCreatedDBObject(br, true);

  491

  492       // Create an attribute reference for our main

  493       // attribute definition (where we'll put the

  494       // bubble's number)

  495

  496       AttributeReference ar =

  497         new AttributeReference();

  498

  499       // Add it to the database, and set its position, etc.

  500

  501       ar.SetDatabaseDefaults();

  502       ar.SetAttributeFromBlock(ad, br.BlockTransform);

  503       ar.Position =

  504         ad.Position.TransformBy(br.BlockTransform);

  505       ar.Tag = ad.Tag;

  506

  507       // Set the bubble's number

  508

  509       int bubbleNumber =

  510         m_baseNumber +

  511         m_nom.NextObjectNumber(blockRefId);

  512

  513       ar.TextString = bubbleNumber.ToString();

  514       ar.AdjustAlignment(db);

  515

  516       // Add the attribute to the block reference

  517

  518       br.AttributeCollection.AppendAttribute(ar);

  519       tr.AddNewlyCreatedDBObject(ar, true);

  520

  521       // Now we add attribute references for the

  522       // other attribute definitions

  523

  524       foreach (AttributeDefinition ad2 in other)

  525       {

  526         AttributeReference ar2 =

  527           new AttributeReference();

  528

  529         ar2.SetAttributeFromBlock(ad2, br.BlockTransform);

  530         ar2.Position =

  531           ad2.Position.TransformBy(br.BlockTransform);

  532         ar2.Tag = ad2.Tag;

  533         ar2.TextString = ad2.TextString;

  534         ar2.AdjustAlignment(db);

  535

  536         br.AttributeCollection.AppendAttribute(ar2);

  537         tr.AddNewlyCreatedDBObject(ar2, true);

  538       }

  539       return br;

  540     }

  541   }

  542

  543   // A generic class for managing groups of

  544   // numbered (and ordered) objects

  545

  546   public class NumberedObjectManager

  547   {

  548     // We need to store a list of object IDs, but

  549     // also a list of free positions in the list

  550     // (this allows numbering gaps)

  551

  552     private List<ObjectId> m_ids;

  553     private List<int> m_free;

  554

  555     // Constructor

  556

  557     public NumberedObjectManager()

  558     {

  559       m_ids =

  560         new List<ObjectId>();

  561

  562       m_free =

  563         new List<int>();

  564     }

  565

  566     // Clear the internal lists

  567

  568     public void Clear()

  569     {

  570       m_ids.Clear();

  571       m_free.Clear();

  572     }

  573

  574     // Return the first entry in the ObjectId list

  575     // (specify "true" if you want to skip

  576     // any null object IDs)

  577

  578     public int GetLowerBound(bool ignoreNull)

  579     {

  580       if (ignoreNull)

  581         // Define an in-line predicate to check

  582         // whether an ObjectId is null

  583         return

  584           m_ids.FindIndex(

  585             delegate(ObjectId id)

  586             {

  587               return id != ObjectId.Null;

  588             }

  589           );

  590       else

  591         return 0;

  592     }

  593

  594     // Return the last entry in the ObjectId list

  595

  596     public int GetUpperBound()

  597     {

  598       return m_ids.Count - 1;

  599     }

  600

  601     // Store the specified ObjectId in the next

  602     // available location in the list, and return

  603     // what that is

  604

  605     public int NextObjectNumber(ObjectId id)

  606     {

  607       int pos;

  608       if (m_free.Count > 0)

  609       {

  610         // Get the first free position, then remove

  611         // it from the "free" list

  612

  613         pos = m_free[0];

  614         m_free.RemoveAt(0);

  615         m_ids[pos] = id;

  616       }

  617       else

  618       {

  619         // There are no free slots (gaps in the numbering)

  620         // so we append it to the list

  621

  622         pos = m_ids.Count;

  623         m_ids.Add(id);

  624       }

  625       return pos;

  626     }

  627

  628     // Store an ObjectId in a particular position

  629     // (shuffle == true will "insert" it, shuffling

  630     // the remaining objects down,

  631     // shuffle == false will replace the item in

  632     // that slot)

  633

  634     public void NumberObject(

  635       ObjectId id, int index, bool shuffle)

  636     {

  637       // If we're inserting into the list

  638

  639       if (index < m_ids.Count)

  640       {

  641         if (shuffle)

  642           // Insert takes care of the shuffling

  643           m_ids.Insert(index, id);

  644         else

  645         {

  646           // If we're replacing the existing item, do

  647           // so and then make sure the slot is removed

  648           // from the "free" list, if applicable

  649

  650           m_ids[index] = id;

  651           if (m_free.Contains(index))

  652             m_free.Remove(index);

  653         }

  654       }

  655       else

  656       {

  657         // If we're appending, shuffling is irrelevant,

  658         // but we may need to add additional "free" slots

  659         // if the position comes after the end

  660

  661         while (m_ids.Count < index)

  662         {

  663           m_ids.Add(ObjectId.Null);

  664           m_free.Add(m_ids.LastIndexOf(ObjectId.Null));

  665           m_free.Sort();

  666         }

  667         m_ids.Add(id);

  668       }

  669     }

  670

  671     // Dump out the object list information

  672     // as well as the "free" slots

  673

  674     public void DumpInfo(Editor ed)

  675     {

  676       if (m_ids.Count > 0)

  677       {

  678         ed.WriteMessage("\nIdx ObjectId");

  679

  680         int index = 0;

  681         foreach (ObjectId id in m_ids)

  682           ed.WriteMessage("\n{0} {1}", index++, id);

  683       }

  684

  685       if (m_free.Count > 0)

  686       {

  687         ed.WriteMessage("\n\nFree list: ");

  688

  689         foreach (int pos in m_free)

  690           ed.WriteMessage("{0} ", pos);

  691       }

  692     }

  693

  694     // Remove the initial n items from the list

  695

  696     public void RebaseList(int start)

  697     {

  698       // First we remove the ObjectIds

  699

  700       for (int i=0; i < start; i++)

  701         m_ids.RemoveAt(0);

  702

  703       // Then we go through the "free" list...

  704

  705       int idx = 0;

  706       while (idx < m_free.Count)

  707       {

  708         if (m_free[idx] < start)

  709           // Remove any that refer to the slots

  710           // we've removed

  711           m_free.RemoveAt(idx);

  712         else

  713         {

  714           // Subtracting the number of slots

  715           // we've removed from the other items

  716           m_free[idx] -= start;

  717           idx++;

  718         }

  719       }

  720     }

  721   }

  722 }

Some information on the changes...

Rather than maintaining an integer for our "current number", we now have an instance of the NumberedObjectManager class, as well as a "base number" should we choose to start the numbering at something other than 0 (see lines 18-23 & 29). We use these variables when numbering the objects at lines 510-511.

We've added a couple of additional commands, LNS (Load Numbering System) and DMP (DuMP numbering system). These commands are announced to the user on load (lines 43-44) and implemented from lines 57-219. The DMP command is really an internal command to show the contents of the number list, while the LNS command analyses the current drawing and determines how the blocks inserted into it have been numbered. Should the numbering start at a higher number than 0, it asks the user whether to re-base the list, which essentially removes the initial entries (from 0 to the new start) and sets the "base number" variable. The function behind the LNS command could have been called automatically on drawing load, but I've chosen to keep it as a command, to allow more control (and to allow the user to re-analyze the drawing, should the numbering for some reason get out of sync).

So why did I choose to implement an analysis command, rather than storing the numbering information in the drawing? Mainly because the quantity of numbered blocks in any real-world (even highly complex) drawing is unlikely to be unmanageable (and therefore slow to analyze), so going to the effort of storing the list in XRecords in the DWG seems like overkill. We would - in any case - want to have something like the LNS command to allow existing drawings to be managed by this system. Seralizing to the drawing is always an option, of course, should your users provide feedback that this approach is innefficient.

The remainder of the changes are for the numbering system itself, the NumberedObjectManager (lines 543-721). As mentioned in the last post, this class has been kept as generic as possible, so it can be used for objects other than blocks, for instance. At the core of the class are two lists:

• m_ids - a list of ObjectIds, which is the list of numbered objects
• m_free - a list of free positions (integers) in the object list, which is useful for us to know the gaps in the list created by object deletion, etc.

An alternative implementation would have been to maintain a "map" between list positions and objects, but using two simple lists makes life easier in certain ways: if we want to delete a number we can simply set its value to ObjectId.Null and add its position to the "free" list, and if we want to move an item in the list we can remove it and insert it elsewhere - the other objects simply shift automatically (although they will need to be updated to reflect their new number, of course - more on this in the next post).

The current implementation fills gaps in the list when we number a new object, but we could very easily adjust the code to ignore those gaps and add numbers at the end.

So let's see what happens when we run the LNS command on the drawing we created in the last post. LNS does nothing very visible - although as we previously started the numbering at 1, it does ask us whether we want to rebase the list. To understand how the numbering system works, let's call LNS and DMP twice, and choosing a different re-basing option each time:

Command: LNS

Lowest index is 1. Make this the start of the list? [Yes/No] <Yes>: No

Command: DMP

Idx ObjectId

0 (0)

1 (2129683752)

2 (2129683776)

3 (2129683800)

4 (2129683824)

5 (2129683848)

6 (2129683872)

7 (2129683896)

8 (2129683920)

9 (2129683944)

10 (2129683968)

11 (2129683992)

12 (2129684016)

13 (2129684040)

14 (2129684064)

15 (2129684088)

16 (2129684112)

17 (2129684136)

18 (2129684160)

19 (2129684184)

20 (2129684208)

Free list: 0

Command: LNS

Lowest index is 1. Make this the start of the list? [Yes/No] <Yes>: Yes

Command: DMP

Idx ObjectId

0 (2129683752)

1 (2129683776)

2 (2129683800)

3 (2129683824)

4 (2129683848)

5 (2129683872)

6 (2129683896)

7 (2129683920)

8 (2129683944)

9 (2129683968)

10 (2129683992)

11 (2129684016)

12 (2129684040)

13 (2129684064)

14 (2129684088)

15 (2129684112)

16 (2129684136)

17 (2129684160)

18 (2129684184)

19 (2129684208)

We can see that the first time we run the LNS command, choosing not to re-base the list, we start the list at 0 and have a free slot at that position. If we start adding more numbered blocks, using the BIC or BAP commands, the system will start by numbering an item with 0 before carrying on at 21, 22, etc.

The second time we run the command, we do re-base the list, which means that our m_baseNumber variable will be set to 1 and will be added each time we map the internal list to what is numbered in the drawing.

That's it for today - in the next post we'll look at some more interesting usage of the numbering system, where we highlight, delete and move items in the list, as well as showing how to fill any gaps automatically.