Through the Interface

19 responses to “Linking Circles, Part 2: Getting persistent”

1. 

   Narayanan

   November 29, 2006 at 2:22 pm

   Hello Kean,

   Great stuff.

   Is it at all possible to avoid Xrecords and still maintain persistency?

   Are there any reactor classes available in dot net api? Like AcDbObjectReactor etc? And if exists, can they be used to derive our own objects from them?

   - Narayanan

   Reply
2. 

   Kean Walmsley

   November 29, 2006 at 6:54 pm

   Hi Narayanan,

   A very good question...

   It's not currently supported to create persistent custom objects (graphical or otherwise) in .NET. This means you can use either Xrecords stored in dictionaries (even entities' extension dictionaries) or xdata to stored custom data. Xrecords are better than xdata, as they don't have the 16K size restriction.

   The logic is that with .NET, apps are more likely to want to store data in an open, readable way (for example as XML fragments in a standard container such as an Xrecord).

   Persistent reactors are not available in .NET right now (they are also part of the custom object debate). Once again, the approach should be similar to the one followed in this app, as it avoids the need for Object Enablers etc.

   Regards,

   Kean

   Reply
3. 

   Glenn R

   November 30, 2006 at 6:58 am

   Kean,
   One wonders how much the code would be reduced if you changed your LinkedObjectManager class to derive from KeyedCollection like so:

   public class LinkedObjectManager : KeyedCollection< ObjectId, ObjectIdCollection > { }

   Good articles - keep them coming. BTW, you made mention of deriving from Dwgfiler in a previous post - can you elucidate?

   Regards,
   Glenn.

   Reply
4. 

   Kean Walmsley

   November 30, 2006 at 2:12 pm

   Hi Glenn,

   Thanks for the suggestion.

   I have to admit I wasn't familiar with the KeyedCollection class, and now that I'm looking into it, I'm curious about its advantages.

   It seems to have the key embedded in the value: this doesn't appear to help us (unless it reduces the need for bi-directional linking... and I can't see how that would be the case).

   It supports serialization, but from what I can tell that was also possible with a Dictionary. I had toyed with serializing our data out as XML to be stored in a single Xrecord, but that raises the issue of object references: Xrecords of soft pointers have the object references translated automatically on load - with XML we would have to use handles. I just ended up just implementing our own serialization protocol...

   As for derivation vs. containment: I went with containment largely to reduce the exposed interface; it made it easier to expose just the "approved" way of adding/deleting items from the map.

   I had to search back through the blog for a reference to deriving from DwgFiler: that was actually something I copy & pasted from a colleague. Generally people do that if they want to capture the data that is stored for certain objects - you pass your derived filer into DwgOutFields() and receive the callbacks in your class. I've only done this from C++, though.

   Regards,

   Kean

   Reply
5. 

   jgeerwm

   September 19, 2007 at 7:46 pm

   Kean,

   Thank you for identifying this pattern. Understanding the API is one thing, knowing how to best put the pieces together is another...

   On line 159 you use the logic: (int)DxfCode.SoftPointerId + i,

   If more than 10 circles are linked to a root circle, doesn't this essentially change the resultbuffer type to a hard pointer?

   Could you please ellaborate on your strategy for incrementing the dxf code?

   Thank you,

   Jeff

   Reply
6. 

   Kean Walmsley

   September 19, 2007 at 9:49 pm

   Jeff,

   Actually you're possibly right... the system might indeed consider us to have hard pointers if we had 10 circles linked directly to a single root circle. As the concept tends to work poorly once you go beyond two links per circle, this wasn't really something I tested, although for linking other types of (particularly non-graphical) object I see where it might become a problem.

   The DXF documentation does say that group codes 0-369 (excluding 5 and 105) can be used by applications "in any way". The implication is that we have complete control, although I'd be interested to see if that were true.

   In any case, the difference between hard and soft pointers is that hard ones prevent purging - something that's not likely to happen on grapical objects such as circles (even by someone implementing purging in their code). The real problem area is more likely to be when you start to get up to 369 (and we're starting at 330 - not so far away).

   Ultimately I see two failsafe solutions:

   1) Limit the creation of links over a certain point (i.e. a single object can only be linked to two others, say).
   2) Reuse the same group codes for your links. This *should* be safe enough - other objects do it - although I haven't tried it myself.

   Thanks for your insightful comment!

   Kean

   Reply
7. 

   Chandru.P

   March 4, 2008 at 9:04 pm

   its a good example to learn linking of objects.
   if any could help me in upgrading this sample so that the linked objects gets automatically loaded on opening the drawing for the second time.
   please provide with me a sample.

   Cheers,

   Reply
8. 

   Kean Walmsley

   March 4, 2008 at 9:30 pm

   I don't have time to do this, but I'd suggest the following approach:

   You don't have a custom object stored in the DWG to drive demand-loading, so have your app load on startup and run a command as it loads (probably by P/Invoking ads_queueexpr()) to do what you need.

   Kean

   Reply
9. 

   SUBIR KUMAR DUTTA

   April 16, 2008 at 11:00 am

   For those who want to copy paste this code and want to run with out wasting time to delete the line numbers. Thanks to Word VBA

   using System;
   using System.Collections;
   using System.Collections.Generic;
   using Autodesk.AutoCAD.Runtime;
   using Autodesk.AutoCAD.ApplicationServices;
   using Autodesk.AutoCAD.DatabaseServices;
   using Autodesk.AutoCAD.EditorInput;
   using Autodesk.AutoCAD.Geometry;

   [assembly:
   CommandClass(
   typeof(
   AsdkLinkingLibrary.LinkingCommands
   )
   )
   ]

   namespace AsdkLinkingLibrary
   {
   /// <summary>
   /// Utility class to manage and save links
   /// between objects
   /// </summary>
   public class LinkedObjectManager
   {
   const string kCompanyDict =
   "AsdkLinks";
   const string kApplicationDict =
   "AsdkLinkedObjects";
   const string kXrecPrefix =
   "LINKXREC";

   Dictionary<objectid, objectidcollection=""> m_dict;

   // Constructor
   public LinkedObjectManager()
   {
   m_dict =
   new Dictionary<objectid,objectidcollection>();
   }

   // Create a bi-directional link between two objects
   public void LinkObjects(ObjectId from, ObjectId to)
   {
   CreateLink(from, to);
   CreateLink(to, from);
   }

   // Helper function to create a one-way
   // link between objects
   private void CreateLink(ObjectId from, ObjectId to)
   {
   ObjectIdCollection existingList;
   if (m_dict.TryGetValue(from, out existingList))
   {
   if (!existingList.Contains(to))
   {
   existingList.Add(to);
   m_dict.Remove(from);
   m_dict.Add(from, existingList);
   }
   }
   else
   {
   ObjectIdCollection newList =
   new ObjectIdCollection();
   newList.Add(to);
   m_dict.Add(from, newList);
   }
   }

   // Remove bi-directional links from an object
   public void RemoveLinks(ObjectId from)
   {
   ObjectIdCollection existingList;
   if (m_dict.TryGetValue(from, out existingList))
   {
   m_dict.Remove(from);
   foreach (ObjectId id in existingList)
   {
   RemoveFromList(id, from);
   }
   }
   }

   // Helper function to remove an object reference
   // from a list (assumes the overall list should
   // remain)
   private void RemoveFromList(
   ObjectId key,
   ObjectId toremove
   )
   {
   ObjectIdCollection existingList;
   if (m_dict.TryGetValue(key, out existingList))
   {
   if (existingList.Contains(toremove))
   {
   existingList.Remove(toremove);
   m_dict.Remove(key);
   m_dict.Add(key, existingList);
   }
   }
   }

   // Return the list of objects linked to
   // the one passed in
   public ObjectIdCollection GetLinkedObjects(
   ObjectId from
   )
   {
   ObjectIdCollection existingList;
   m_dict.TryGetValue(from, out existingList);
   return existingList;
   }

   // Check whether the dictionary contains
   // a particular key
   public bool Contains(ObjectId key)
   {
   return m_dict.ContainsKey(key);
   }

   // Save the link information to a special
   // dictionary in the database
   public void SaveToDatabase(Database db)
   {
   Transaction tr =
   db.TransactionManager.StartTransaction();
   using (tr)
   {
   ObjectId dictId =
   GetLinkDictionaryId(db, true);
   DBDictionary dict =
   (DBDictionary)tr.GetObject(
   dictId,
   OpenMode.ForWrite
   );
   int xrecCount = 0;

   foreach (
   KeyValuePair<objectid, objectidcollection=""> kv
   in m_dict
   )
   {
   // Prepare the result buffer with our data
   ResultBuffer rb =
   new ResultBuffer(
   new TypedValue(
   (int)DxfCode.SoftPointerId,
   kv.Key
   )
   );
   int i = 1;
   foreach (ObjectId id in kv.Value)
   {
   rb.Add(
   new TypedValue(
   (int)DxfCode.SoftPointerId + i,
   id
   )
   );
   i++;
   }

   // Update or create an xrecord to store the data
   Xrecord xrec;
   bool newXrec = false;
   if (dict.Contains(
   kXrecPrefix + xrecCount.ToString()
   )
   )
   {
   // Open the existing object
   DBObject obj =
   tr.GetObject(
   dict.GetAt(
   kXrecPrefix + xrecCount.ToString()
   ),
   OpenMode.ForWrite
   );
   // Check whether it's an xrecord
   xrec = obj as Xrecord;
   if (xrec == null)
   {
   // Should never happen
   // We only store xrecords in this dict
   obj.Erase();
   xrec = new Xrecord();
   newXrec = true;
   }
   }
   // No object existed - create a new one
   else
   {
   xrec = new Xrecord();
   newXrec = true;
   }
   xrec.XlateReferences = true;
   xrec.Data = (ResultBuffer)rb;
   if (newXrec)
   {
   dict.SetAt(
   kXrecPrefix + xrecCount.ToString(),
   xrec
   );
   tr.AddNewlyCreatedDBObject(xrec, true);
   }
   xrecCount++;
   }

   // Now erase the left-over xrecords
   bool finished = false;
   do
   {
   if (dict.Contains(
   kXrecPrefix + xrecCount.ToString()
   )
   )
   {
   DBObject obj =
   tr.GetObject(
   dict.GetAt(
   kXrecPrefix + xrecCount.ToString()
   ),
   OpenMode.ForWrite
   );
   obj.Erase();
   }
   else
   {
   finished = true;
   }
   xrecCount++;
   } while (!finished);
   tr.Commit();
   }
   }

   // Load the link information from a special
   // dictionary in the database
   public void LoadFromDatabase(Database db)
   {
   Document doc =
   Application.DocumentManager.MdiActiveDocument;
   Editor ed = doc.Editor;
   Transaction tr =
   db.TransactionManager.StartTransaction();
   using (tr)
   {
   // Try to find the link dictionary, but
   // do not create it if one isn't there
   ObjectId dictId =
   GetLinkDictionaryId(db, false);
   if (dictId.IsNull)
   {
   ed.WriteMessage(
   "\nCould not find link dictionary."
   );
   return;
   }

   // By this stage we can assume the dictionary exists
   DBDictionary dict =
   (DBDictionary)tr.GetObject(
   dictId, OpenMode.ForRead
   );
   int xrecCount = 0;
   bool done = false;

   // Loop, reading the xrecords one-by-one
   while (!done)
   {
   if (dict.Contains(
   kXrecPrefix + xrecCount.ToString()
   )
   )
   {
   ObjectId recId =
   dict.GetAt(
   kXrecPrefix + xrecCount.ToString()
   );
   DBObject obj =
   tr.GetObject(recId, OpenMode.ForRead);
   Xrecord xrec = obj as Xrecord;
   if (xrec == null)
   {
   ed.WriteMessage(
   "\nDictionary contains non-xrecords."
   );
   return;
   }
   int i = 0;
   ObjectId from = new ObjectId();
   ObjectIdCollection to =
   new ObjectIdCollection();
   foreach (TypedValue val in xrec.Data)
   {
   if (i == 0)
   from = (ObjectId)val.Value;
   else
   {
   to.Add((ObjectId)val.Value);
   }
   i++;
   }
   // Validate the link info and add it to our
   // internal data structure
   AddValidatedLinks(db, from, to);
   xrecCount++;
   }
   else
   {
   done = true;
   }
   }
   tr.Commit();
   }
   }

   // Helper function to validate links before adding
   // them to the internal data structure
   private void AddValidatedLinks(
   Database db,
   ObjectId from,
   ObjectIdCollection to
   )
   {
   Document doc =
   Application.DocumentManager.MdiActiveDocument;
   Editor ed = doc.Editor;
   Transaction tr =
   db.TransactionManager.StartTransaction();
   using (tr)
   {
   try
   {
   ObjectIdCollection newList =
   new ObjectIdCollection();

   // Open the "from" object
   DBObject obj =
   tr.GetObject(from, OpenMode.ForRead, false);
   if (obj != null)
   {
   // Open each of the "to" objects
   foreach (ObjectId id in to)
   {
   DBObject obj2;
   try
   {
   obj2 =
   tr.GetObject(id, OpenMode.ForRead, false);
   // Filter out the erased "to" objects
   if (obj2 != null)
   {
   newList.Add(id);
   }
   }
   catch (System.Exception)
   {
   ed.WriteMessage(
   "\nFiltered out link to an erased object."
   );
   }
   }
   // Only if the "from" object and at least
   // one "to" object exist (and are unerased)
   // do we add an entry for them
   if (newList.Count > 0)
   {
   m_dict.Add(from, newList);
   }
   }
   }
   catch (System.Exception)
   {
   ed.WriteMessage(
   "\nFiltered out link from an erased object."
   );
   }
   tr.Commit();
   }
   }

   // Helper function to get (optionally create)
   // the nested dictionary for our xrecord objects
   private ObjectId GetLinkDictionaryId(
   Database db,
   bool createIfNotExisting
   )
   {
   ObjectId appDictId = ObjectId.Null;

   Transaction tr =
   db.TransactionManager.StartTransaction();
   using (tr)
   {
   DBDictionary nod =
   (DBDictionary)tr.GetObject(
   db.NamedObjectsDictionaryId,
   OpenMode.ForRead
   );
   // Our outer level ("company") dictionary
   // does not exist
   if (!nod.Contains(kCompanyDict))
   {
   if (!createIfNotExisting)
   return ObjectId.Null;

   // Create both the "company" dictionary...
   DBDictionary compDict = new DBDictionary();
   nod.UpgradeOpen();
   nod.SetAt(kCompanyDict, compDict);
   tr.AddNewlyCreatedDBObject(compDict, true);

   // ... and the inner "application" dictionary.
   DBDictionary appDict = new DBDictionary();
   appDictId =
   compDict.SetAt(kApplicationDict, appDict);
   tr.AddNewlyCreatedDBObject(appDict, true);
   }
   else
   {
   // Our "company" dictionary exists...
   DBDictionary compDict =
   (DBDictionary)tr.GetObject(
   nod.GetAt(kCompanyDict),
   OpenMode.ForRead
   );
   /// So check for our "application" dictionary
   if (!compDict.Contains(kApplicationDict))
   {
   if (!createIfNotExisting)
   return ObjectId.Null;

   // Create the "application" dictionary
   DBDictionary appDict = new DBDictionary();
   compDict.UpgradeOpen();
   appDictId =
   compDict.SetAt(kApplicationDict, appDict);
   tr.AddNewlyCreatedDBObject(appDict, true);
   }
   else
   {
   // Both dictionaries already exist...
   appDictId = compDict.GetAt(kApplicationDict);
   }
   }
   tr.Commit();
   }
   return appDictId;
   }
   }

   /// <summary>
   /// This class defines our commands and event callbacks.
   /// </summary>
   public class LinkingCommands
   {
   LinkedObjectManager m_linkManager;
   ObjectIdCollection m_entitiesToUpdate;

   public LinkingCommands()
   {
   Document doc =
   Application.DocumentManager.MdiActiveDocument;
   Database db = doc.Database;
   db.ObjectModified +=
   new ObjectEventHandler(OnObjectModified);
   db.ObjectErased +=
   new ObjectErasedEventHandler(OnObjectErased);
   db.BeginSave +=
   new DatabaseIOEventHandler(OnBeginSave);
   doc.CommandEnded +=
   new CommandEventHandler(OnCommandEnded);

   m_linkManager = new LinkedObjectManager();
   m_entitiesToUpdate = new ObjectIdCollection();
   }

   ~LinkingCommands()
   {
   try
   {
   Document doc =
   Application.DocumentManager.MdiActiveDocument;
   Database db = doc.Database;
   db.ObjectModified -=
   new ObjectEventHandler(OnObjectModified);
   db.ObjectErased -=
   new ObjectErasedEventHandler(OnObjectErased);
   db.BeginSave -=
   new DatabaseIOEventHandler(OnBeginSave);
   doc.CommandEnded +=
   new CommandEventHandler(OnCommandEnded);
   }
   catch(System.Exception)
   {
   // The document or database may no longer
   // be available on unload
   }
   }

   // Define "LINK" command
   [CommandMethod("LINK")]
   public void LinkEntities()
   {
   Document doc =
   Application.DocumentManager.MdiActiveDocument;
   Database db = doc.Database;
   Editor ed = doc.Editor;

   PromptEntityOptions opts =
   new PromptEntityOptions(
   "\nSelect first circle to link: "
   );
   opts.AllowNone = true;
   opts.SetRejectMessage(
   "\nOnly circles can be selected."
   );
   opts.AddAllowedClass(typeof(Circle), false);

   PromptEntityResult res = ed.GetEntity(opts);
   if (res.Status == PromptStatus.OK)
   {
   ObjectId from = res.ObjectId;
   opts.Message =
   "\nSelect second circle to link: ";
   res = ed.GetEntity(opts);
   if (res.Status == PromptStatus.OK)
   {
   ObjectId to = res.ObjectId;
   m_linkManager.LinkObjects(from, to);
   m_entitiesToUpdate.Add(from);
   }
   }
   }

   // Define "LOADLINKS" command
   [CommandMethod("LOADLINKS")]
   public void LoadLinkSettings()
   {
   Document doc =
   Application.DocumentManager.MdiActiveDocument;
   Database db = doc.Database;
   m_linkManager.LoadFromDatabase(db);
   }

   // Define "SAVELINKS" command
   [CommandMethod("SAVELINKS")]
   public void SaveLinkSettings()
   {
   Document doc =
   Application.DocumentManager.MdiActiveDocument;
   Database db = doc.Database;
   m_linkManager.SaveToDatabase(db);
   }

   // Define callback for Database.ObjectModified event
   private void OnObjectModified(
   object sender, ObjectEventArgs e)
   {
   ObjectId id = e.DBObject.ObjectId;
   if (m_linkManager.Contains(id) &&
   !m_entitiesToUpdate.Contains(id))
   {
   m_entitiesToUpdate.Add(id);
   }
   }

   // Define callback for Database.ObjectErased event
   private void OnObjectErased(
   object sender, ObjectErasedEventArgs e)
   {
   if (e.Erased)
   {
   m_linkManager.RemoveLinks(e.DBObject.ObjectId);
   }
   }

   // Define callback for Database.BeginSave event
   void OnBeginSave(object sender, DatabaseIOEventArgs e)
   {
   Database db = sender as Database;
   if (db != null)
   {
   m_linkManager.SaveToDatabase(db);
   }
   }

   // Define callback for Document.CommandEnded event
   private void OnCommandEnded(
   object sender, CommandEventArgs e)
   {
   foreach (ObjectId id in m_entitiesToUpdate)
   {
   UpdateLinkedEntities(id);
   }
   m_entitiesToUpdate.Clear();
   }

   // Helper function for OnCommandEnded
   private void UpdateLinkedEntities(ObjectId from)
   {
   Document doc =
   Application.DocumentManager.MdiActiveDocument;
   Editor ed = doc.Editor;
   Database db = doc.Database;

   ObjectIdCollection linked =
   m_linkManager.GetLinkedObjects(from);

   Transaction tr =
   db.TransactionManager.StartTransaction();
   using (tr)
   {
   try
   {
   Point3d firstCenter;
   Point3d secondCenter;
   double firstRadius;
   double secondRadius;

   Entity ent =
   (Entity)tr.GetObject(from, OpenMode.ForRead);

   if (GetCenterAndRadius(
   ent,
   out firstCenter,
   out firstRadius
   )
   )
   {
   foreach (ObjectId to in linked)
   {
   Entity ent2 =
   (Entity)tr.GetObject(to, OpenMode.ForRead);
   if (GetCenterAndRadius(
   ent2,
   out secondCenter,
   out secondRadius
   )
   )
   {
   Vector3d vec = firstCenter - secondCenter;
   if (!vec.IsZeroLength())
   {
   // Only move the linked circle if it's not
   // already near enough
   double apart =
   vec.Length - (firstRadius + secondRadius);
   if (apart < 0.0)
   apart = -apart;

   if (apart > 0.00001)
   {
   ent2.UpgradeOpen();
   ent2.TransformBy(
   Matrix3d.Displacement(
   vec.GetNormal() * apart
   )
   );
   }
   }
   }
   }
   }
   }
   catch (System.Exception ex)
   {
   Autodesk.AutoCAD.Runtime.Exception ex2 =
   ex as Autodesk.AutoCAD.Runtime.Exception;
   if (ex2 != null &&
   ex2.ErrorStatus != ErrorStatus.WasOpenForUndo)
   {
   ed.WriteMessage(
   "\nAutoCAD exception: {0}", ex2
   );
   }
   else if (ex2 == null)
   {
   ed.WriteMessage(
   "\nSystem exception: {0}", ex
   );
   }
   }
   tr.Commit();
   }
   }

   // Helper function to get the center and radius
   // for all supported circular objects
   private bool GetCenterAndRadius(
   Entity ent,
   out Point3d center,
   out double radius
   )
   {
   // For circles it's easy...
   Circle circle = ent as Circle;
   if (circle != null)
   {
   center = circle.Center;
   radius = circle.Radius;
   return true;
   }
   else
   {
   // Throw in some empty values...
   // Returning false indicates the object
   // passed in was not useable
   center = Point3d.Origin;
   radius = 0.0;
   return false;
   }
   }
   }
   }

   Reply
10. 

    Kean Walmsley

    April 18, 2008 at 1:14 pm

    Subir - the source file is linked to for download from within the post.

    Kean

    Reply
11. 

    Sinc

    September 1, 2008 at 2:11 am

    I notice that in this code, the ObjectModified event handler adds ObjectIds to a list, which is processed in the CommandEnded event handler.

    However, this means that the list of modified ObjectIds does not get processed when objects are modified in ways that do not involve standard commands. For example, if we change the location of the lead circle in the chain by changing the X or Y coordinates in the Properties panel, the CommandEnded event handler does not fire.

    A similar issue happens in vertical apps such as Civil-3D, where editing feature lines using the Elevation Editor does not trigger the CommandEnded event.

    Is there a way to catch user actions such as this, and trigger the processing of the list?

    Reply
12. 

    Kean Walmsley

    September 1, 2008 at 11:48 am

    It's probably because I worked off an old (R13-era) ObjectARX sample when I created this. The more modern way to pick up changes made by all types of operation (not just commands) is to handle this event:

    Application.DocumentManager.DocumentLockModeWillChange

    Regards,

    Kean

    Reply
13. 

    Sinc

    September 1, 2008 at 7:19 pm

    I have some code that monitors various objects, and when one of the objects is changed, the elevation of various C3D points gets changed. This code runs fine when I run it from the CommandEnded event handler, except for the issue mentioned above, where items can be changed in ways that do not trigger CommandEnded.

    But when I try to run it from the DocumentLockModeWillChange event handler, it hits a problem while trying to update the elevations of the AeccCogoPoints. The line that sets the new elevation causes my code to stop running, and C3D displays a "Command is already in progress" error message on the command line. The next thing I attempt to do will crash C3D.

    Any ideas why this might be happening? I am maintaining a list of ObjectIDs, and I retrieve these objects via a transaction in my event handler. I then turn them into AeccPoint objects, by casting "aeccPt = dbObj.AcadObject as AeccPoint". It is when I try to set the aeccPt.Elevation property that I trigger the problem.

    Is the problem caused by the fact that I am converting the point from a generic DBObject to a COM object inside the event handler? If so, how should I go about this task?

    Reply
14. 

    Kean Walmsley

    September 1, 2008 at 7:38 pm

    You probably need to check the current and new states of the document's lock mode (via the event handler's arguments). You won't want to run your code for every lock change, probably only when Current (or MyCurrent) is "Write" and MyFuture is "None", for instance.

    At least that's my suspicion without seeing your code...

    Kean

    Reply
15. 

    Sinc

    September 2, 2008 at 12:07 am

    I have distilled the problem down to a minimal amount of code.

    The following code has an ADDTESTPTS command, which adds Cogo points to the list of watched ObjectIds. When a watched point is modified, this code should add 1 to the elevation. It works when I use the CommandEnded handler, but not the DocumentLockModeWillChange handler.

    using Autodesk.AutoCAD.ApplicationServices;
    using Autodesk.AutoCAD.DatabaseServices;
    using Autodesk.AutoCAD.EditorInput;
    using Autodesk.AutoCAD.Runtime;
    using Autodesk.AECC.Interop.Land;

    namespace Test
    {
    public class PointTest
    {
    ObjectIdCollection m_entitiesToUpdate;
    ObjectIdCollection m_modifiedEntities;

    public PointTest()
    {
    // Code currently works as-is, except it only works when the CommandEnded event handler gets fired.
    // However, comment out the following line:
    Application.DocumentManager.MdiActiveDocument.CommandEnded += new CommandEventHandler(MdiActiveDocument_CommandEnded);

    // and enable this line instead:
    //Application.DocumentManager.DocumentLockModeWillChange += new DocumentLockModeWillChangeEventHandler(DocumentManager_DocumentLockModeWillChange);

    // ...and now Civil-3D will display a "Command in progress" error whenever a watched point is modified,
    // and then fatal error soon after.

    HostApplicationServices.WorkingDatabase.ObjectModified += new ObjectEventHandler(WorkingDatabase_ObjectModified);

    m_entitiesToUpdate = new ObjectIdCollection();
    m_modifiedEntities = new ObjectIdCollection();
    }

    [CommandMethod("ADDTESTPTS")]
    public void AddTestPoints()
    {
    PromptSelectionOptions sPrmpt = new PromptSelectionOptions();
    PromptSelectionResult ssResult;
    TypedValue[] filter = new TypedValue[1];
    filter[0] = new TypedValue(0, "AECC_COGO_POINT");
    SelectionFilter ssFilter = new SelectionFilter(filter);
    ssResult = Application.DocumentManager.MdiActiveDocument.Editor.GetSelection(sPrmpt, ssFilter);
    if (ssResult.Status == PromptStatus.OK)
    {
    ObjectId[] objIds = ssResult.Value.GetObjectIds();
    foreach (ObjectId oid in objIds)
    m_entitiesToUpdate.Add(oid);
    }
    }

    void WorkingDatabase_ObjectModified(object sender, ObjectEventArgs e)
    {
    if (m_entitiesToUpdate.Contains(e.DBObject.ObjectId) && !m_modifiedEntities.Contains(e.DBObject.ObjectId))
    m_modifiedEntities.Add(e.DBObject.ObjectId);
    }

    void MdiActiveDocument_CommandEnded(object sender, CommandEventArgs e)
    {
    UpdatePoints(HostApplicationServices.WorkingDatabase);
    }

    void DocumentManager_DocumentLockModeWillChange(object sender, DocumentLockModeWillChangeEventArgs e)
    {
    if ((e.MyCurrentMode == DocumentLockMode.Write) &&
    ((e.MyNewMode == DocumentLockMode.NotLocked) || (e.MyNewMode == DocumentLockMode.None)))
    {
    UpdatePoints(e.Document.Database);
    }
    }

    void UpdatePoints(Database db)
    {
    if (m_modifiedEntities.Count > 0)
    {
    using (Transaction tr = db.TransactionManager.StartTransaction())
    {
    foreach (ObjectId oid in m_modifiedEntities)
    {
    DBObject obj = tr.GetObject(oid, OpenMode.ForWrite);
    AeccPoint pt = obj.AcadObject as AeccPoint;
    if (pt != null)
    {
    double elev = pt.Elevation;
    pt.Elevation = elev + 1;
    }
    }
    tr.Commit();
    }
    m_modifiedEntities.Clear();
    }
    }
    }
    }

    Reply
16. 

    Kean Walmsley

    September 2, 2008 at 12:24 pm

    I can't see anything wrong with this code, but I don't use Civil 3D and so can't try it out.

    I suggest submitting it via the ADN website (if you're a member) or posting it to the AutoCAD Civil 3D Customization Discussion Group, otherwise.

    Regards,

    Kean

    Reply
17. 

    Sinc

    September 7, 2008 at 4:35 pm

    After posting to the DGs, nobody seems to have any idea why DocumentLockModeWillChange doesn't work in C3D.

    But it looks like everything works OK when monitoring Editor.EnteringQuiescentState instead.

    Reply
18. 

    Gustavo B

    October 3, 2014 at 8:34 pm

    Hi Kean,

    Is there any way to know if the position of a block has been changed via the properties panel. Maybe some Overrule or Event, other than the ObjectModified event?

    Thanks,

    Gustavo Barreto

    Reply
    1. 

       Kean Walmsley

       October 4, 2014 at 5:49 pm

       Hi Gustavo,

       I'm pretty sure you just have ObjectModified. Are you trying to adjust positioning or stop it from happening? If so, you might be able to overrule the property availability/behaviour (although I haven't done it myself).

       Regards,

       Kean

       Reply