Kean专题(5)—Commands

雪山飞狐_lzh

十一、
August 08, 2008
Catching exceptions thrown from dialogs inside AutoCAD using .NET
Another juicy tidbit from an internal Q&A session.
The question...
How can I throw an exception from within a modal form on mine inside AutoCAD, and catch it in the calling command? I have tried try/catch, but nothing seems to work.
Here's my command definition:

2. using Autodesk.AutoCAD.ApplicationServices;
3. using Autodesk.AutoCAD.Runtime;
4. using System.Windows.Forms;
5. using MyApplication;
6. using acApp =
7.   Autodesk.AutoCAD.ApplicationServices.Application;
8. namespace CatchMeIfYouCan
9. {
10.   public class Commands
11.   {
12.     [CommandMethod("CATCH")]
13.     static public void CatchDialogException()
14.     {
15.       try
16.       {
17.         MyForm form = new MyForm();
18.         DialogResult res =
19.           acApp.ShowModalDialog(form);
20.       }
21.       catch (System.Exception ex)
22.       {
23.         MessageBox.Show(
24.           "Caught using catch: " +
25.           ex.Message,
26.           "Exception"
27.         );
28.       }
29.     }
30.   }
31. }

using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.Runtime; using System.Windows.Forms; using MyApplication; using acApp =   Autodesk.AutoCAD.ApplicationServices.Application; namespace CatchMeIfYouCan {   public class Commands   {     [CommandMethod("CATCH")]     static public void CatchDialogException()     {       try       {         MyForm form = new MyForm();         DialogResult res =           acApp.ShowModalDialog(form);       }       catch (System.Exception ex)       {         MessageBox.Show(           "Caught using catch: " +           ex.Message,           "Exception"         );       }     }   } }

And here's the code that throws an exception from behind button inside my form:

2. using System;
3. using System.Windows.Forms;
4. namespace MyApplication
5. {
6.   public partial class MyForm : Form
7.   {
8.     public MyForm()
9.     {
10.       InitializeComponent();
11.     }
12.     private void button1_Click(
13.       object sender,
14.       EventArgs e
15.     )
16.     {
17.       throw new Exception(
18.         "Something bad happened."
19.       );
20.     }
21.   }
22. }

using System; using System.Windows.Forms; namespace MyApplication {   public partial class MyForm : Form   {     public MyForm()     {       InitializeComponent();     }     private void button1_Click(       object sender,       EventArgs e     )     {       throw new Exception(         "Something bad happened."       );     }   } }

The answer, once again, came from our AutoCAD Engineering team, in this case from one of our API Test Engineers based in Singapore...
I was able to catch the exception using the ThreadExceptionEventHandler event. Here is your modified command:

2. using Autodesk.AutoCAD.ApplicationServices;
3. using Autodesk.AutoCAD.EditorInput;
4. using Autodesk.AutoCAD.Runtime;
5. using Autodesk.AutoCAD.Windows;
6. using System.Windows.Forms;
7. using System.Threading;
8. using MyApplication;
9. using acApp =
10.   Autodesk.AutoCAD.ApplicationServices.Application;
11. using sysApp =
12.   System.Windows.Forms.Application;
13. namespace CatchMeIfYouCan
14. {
15.   public class Commands
16.   {
17.     [CommandMethod("CATCH")]
18.     static public void CatchDialogException()
19.     {
20.       try
21.       {
22.         sysApp.ThreadException +=
23.           new ThreadExceptionEventHandler(
24.             delegate(
25.               object o,
26.               ThreadExceptionEventArgs args
27.             )
28.             {
29.               MessageBox.Show(
30.                 "Caught using event: " +
31.                 args.Exception.Message,
32.                 "Exception"
33.               );
34.             }
35.           );
36.         MyForm form = new MyForm();
37.         DialogResult res =
38.           acApp.ShowModalDialog(form);
39.       }
40.       catch (System.Exception ex)
41.       {
42.         MessageBox.Show(
43.           "Caught using catch: " +
44.           ex.Message,
45.           "Exception"
46.         );
47.       }
48.     }
49.   }
50. }

using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.Windows; using System.Windows.Forms; using System.Threading; using MyApplication; using acApp =   Autodesk.AutoCAD.ApplicationServices.Application; using sysApp =   System.Windows.Forms.Application; namespace CatchMeIfYouCan {   public class Commands   {     [CommandMethod("CATCH")]     static public void CatchDialogException()     {       try       {         sysApp.ThreadException +=           new ThreadExceptionEventHandler(             delegate(               object o,               ThreadExceptionEventArgs args             )             {               MessageBox.Show(                 "Caught using event: " +                 args.Exception.Message,                 "Exception"               );             }           );         MyForm form = new MyForm();         DialogResult res =           acApp.ShowModalDialog(form);       }       catch (System.Exception ex)       {         MessageBox.Show(           "Caught using catch: " +           ex.Message,           "Exception"         );       }     }   } }

I gave this a try, myself, and saw that when we click the button on the dialog shown by the CATCH command, our event handler picks up the exception and displays it via a MessageBox:

One thing to note: when running this from the debugger, Visual Studio will break, telling us that there's an exception that has gone unhandled:

This can be ignored - and probably disabled inside Visual Studio - but it could be annoying, if you use this technique throughout your code. Perhaps someone who's implemented this approach - or another that works for them - can add a comment on how they handle this scenario?

雪山飞狐_lzh

十二、
September 05, 2008
No muttering at the back! Reducing the background noise when sending commands to AutoCAD
Since posting three different options for Zooming to a Window or Entity inside AutoCAD, I've had a few discussions with a developer on how best to implement this cleanly. The requirement is to change the AutoCAD view via a smooth view transition (currently not exposed via any kind of view-modification API, only via the ZOOM command), but also to hide the fact we're sending commands to the command-line to do so.
While we were discussing, I remembered an old friend, the NOMUTT system variable, which allows almost all command-line noise to be filtered out - even the "Command:" prompt disappears. While this technique is useful for this specific situation, it's also potentially very useful for many other instances where sending commands are currently the best available method of accessing particular functionality inside AutoCAD.
A word of caution: setting NOMUTT to 1 can lead to severe user-disorientation. Please remember to set the variable back to 0, afterwards!
Here's the modified C# code showing this technique - this time using SendStringToExecute() from the .NET API, rather than the COM API's synchronous SendCommand():

2. using Autodesk.AutoCAD.ApplicationServices;
3. using Autodesk.AutoCAD.DatabaseServices;
4. using Autodesk.AutoCAD.EditorInput;
5. using Autodesk.AutoCAD.Runtime;
6. using Autodesk.AutoCAD.Geometry;
7. namespace ZoomSmoothlyAndQuietly
8. {
9.   public class Commands
10.   {
11.     // Zoom to a window specified by the user
12.     [CommandMethod("LZW")]
13.     static public void LoudZoomWindow()
14.     {
15.       Document doc =
16.         Application.DocumentManager.MdiActiveDocument;
17.       Editor ed = doc.Editor;
18.       Point2d min, max;
19.       if (GetWindowForZoom(ed, out min, out max))
20.         ZoomWin(ed, min, max, false);
21.     }
22.     [CommandMethod("QZW")]
23.     static public void QuietZoomWindow()
24.     {
25.       Document doc =
26.         Application.DocumentManager.MdiActiveDocument;
27.       Editor ed = doc.Editor;
28.       Point2d min, max;
29.       if (GetWindowForZoom(ed, out min, out max))
30.         ZoomWin(ed, min, max, true);
31.     }
32.     // Get the coordinates for a zoom
33.     static private bool GetWindowForZoom(
34.       Editor ed, out Point2d min, out Point2d max
35.     )
36.     {
37.       min = new Point2d();
38.       max = new Point2d();
39.       PromptPointOptions ppo =
40.         new PromptPointOptions(
41.           "\nSpecify first corner:"
42.         );
43.       PromptPointResult ppr =
44.         ed.GetPoint(ppo);
45.       if (ppr.Status != PromptStatus.OK)
46.         return false;
47.       min =
48.         new Point2d(ppr.Value.X, ppr.Value.Y);
49.       PromptCornerOptions pco =
50.         new PromptCornerOptions(
51.           "\nSpecify opposite corner: ",
52.           ppr.Value
53.         );
54.       ppr = ed.GetCorner(pco);
55.       if (ppr.Status != PromptStatus.OK)
56.         return false;
57.       max =
58.         new Point2d(ppr.Value.X, ppr.Value.Y) ;
59.       return true;
60.     }
61.     // Zoom by sending a command
62.     private static void ZoomWin(
63.       Editor ed, Point2d min, Point2d max, bool quietly
64.     )
65.     {
66.       string lower =
67.         min.ToString().Substring(
68.           1,
69.           min.ToString().Length - 2
70.         );
71.       string upper =
72.         max.ToString().Substring(
73.           1,
74.           max.ToString().Length - 2
75.         );
76.       string cmd =
77.         "_.ZOOM _W " + lower + " " + upper + " ";
78.       if (quietly)
79.       {
80.         // Get the old value of NOMUTT
81.         object nomutt =
82.           Application.GetSystemVariable("NOMUTT");
83.         // Add the string to reset NOMUTT afterwards
84.         cmd += "_NOMUTT " + nomutt.ToString() + " ";
85.         // Set NOMUTT to 1, reducing cmd-line noise
86.         Application.SetSystemVariable("NOMUTT", 1);
87.       }
88.       // Send the command(s)
89.       ed.Document.SendStringToExecute(
90.         cmd, true, false, !quietly
91.       );
92.     }
93.   }
94. }

using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.Geometry; namespace ZoomSmoothlyAndQuietly {   public class Commands   {     // Zoom to a window specified by the user     [CommandMethod("LZW")]     static public void LoudZoomWindow()     {       Document doc =         Application.DocumentManager.MdiActiveDocument;       Editor ed = doc.Editor;       Point2d min, max;       if (GetWindowForZoom(ed, out min, out max))         ZoomWin(ed, min, max, false);     }     [CommandMethod("QZW")]     static public void QuietZoomWindow()     {       Document doc =         Application.DocumentManager.MdiActiveDocument;       Editor ed = doc.Editor;       Point2d min, max;       if (GetWindowForZoom(ed, out min, out max))         ZoomWin(ed, min, max, true);     }     // Get the coordinates for a zoom     static private bool GetWindowForZoom(       Editor ed, out Point2d min, out Point2d max     )     {       min = new Point2d();       max = new Point2d();       PromptPointOptions ppo =         new PromptPointOptions(           "\nSpecify first corner:"         );       PromptPointResult ppr =         ed.GetPoint(ppo);       if (ppr.Status != PromptStatus.OK)         return false;       min =         new Point2d(ppr.Value.X, ppr.Value.Y);       PromptCornerOptions pco =         new PromptCornerOptions(           "\nSpecify opposite corner: ",           ppr.Value         );       ppr = ed.GetCorner(pco);       if (ppr.Status != PromptStatus.OK)         return false;       max =         new Point2d(ppr.Value.X, ppr.Value.Y) ;       return true;     }     // Zoom by sending a command     private static void ZoomWin(       Editor ed, Point2d min, Point2d max, bool quietly     )     {       string lower =         min.ToString().Substring(           1,           min.ToString().Length - 2         );       string upper =         max.ToString().Substring(           1,           max.ToString().Length - 2         );       string cmd =         "_.ZOOM _W " + lower + " " + upper + " ";       if (quietly)       {         // Get the old value of NOMUTT         object nomutt =           Application.GetSystemVariable("NOMUTT");         // Add the string to reset NOMUTT afterwards         cmd += "_NOMUTT " + nomutt.ToString() + " ";         // Set NOMUTT to 1, reducing cmd-line noise         Application.SetSystemVariable("NOMUTT", 1);       }       // Send the command(s)       ed.Document.SendStringToExecute(         cmd, true, false, !quietly       );     }   } }

Here's what happens when we run the "loud" command (LZW), and then the "quiet" one (QZW):

1. Command: LZW
2. Specify first corner:
3. Specify opposite corner:
4. Command: _.ZOOM
5. Specify corner of window, enter a scale factor (nX or nXP), or
6. [All/Center/Dynamic/Extents/Previous/Scale/Window/Object] <real time>: _W
7. Specify first corner: 13.1961936276982,12.972925917324 Specify opposite corner:
8. 30.6221132095147,0.482638801189623
9. Command: QZW
10. Specify first corner:
11. Specify opposite corner:
12. Command:

复制代码

Both versions of the command deliver the results in terms of smooth view transitions, but the quiet version reduces the command-line clutter by a) passing a flag to SendStringToExecute() to stop the command from being echoed and b) setting the NOMUTT system variable to prevent the command "muttering" from being echoed. It uses a simple trick to reset the system variable afterwards by appending "_NOMUTT 0 " to the string to be executed (which we don't see, as NOMUTT is still set to 1 :-). Assuming the ZOOM command terminates correctly, the NOMUTT system variable should be reset: there is a slight risk that something causes ZOOM to fail, at which point it might be worth checking NOMUTT from time to time elsewhere in your app: as mentioned earlier, having NOMUTT set to 1 can be very disconcerting for the user. I should, in fact, probably just force NOMUTT to 0 after the ZOOM (if you check the the above code, you'll see we reset it to the prior value, which is generally a good technique when modifying system variables as they retain the value previously chosen by the user). Anyway - I'll leave the final choice up to you, but do be aware of the risk.
Update:
Undo is a problem with this implementation - havin NOMUTT as a separate command leaves it at risk of being undone by the user (leaving the system in a scary, silent state). This post presents an enhanced approach which provides much better support for undo.

雪山飞狐_lzh

September 15, 2008
More quiet command-calling: adding an inspection dimension inside AutoCAD using .NET
I'm still a little frazzled after transcribing the 18,000 word interview with John Walker (and largely with two fingers - at such times the fact that I've never learned to touch-type is a significant cause of frustration, as you might imagine). I'm also attending meetings all this coming week, so I've gone for the cheap option, once again, of dipping into my magic folder of code generated and provided by my team.
The technique for this one came from a response sent out by Philippe Leefsma, from DevTech EMEA, but he did mention a colleague helped him by suggesting the technique. So thanks to Philippe and our anonymous colleague for the initial idea of calling -DIMINSPECT.
The problem solved by Philippe's code is that no API is exposed via .NET to enable the "inspection" capability of dimensions inside AutoCAD. The protocol is there in ObjectARX, in the AcDbDimension class, but this has - at the time of writing - not been exposed via  the managed API. One option would be to create a wrapper or mixed-mode module to call through to unmanaged C++, but the following approach simply calls through to the -DIMINSPECT command (the command-line version of DIMINSPECT) to set the inspection parameters.
I've integrated - and extended - the technique shown in this previous post to send the command as quietly as possible. One problem I realised with the previous implementation is that UNDO might leave the user in a problematic state - with the NOMUTT variable set to 1. This modified approach does a couple of things differently:
Rather than using the NOMUTT command to set the system variable, it launches another custom command, FINISH_COMMAND
This command has been registered with the NoUndoMarker command-flag, to make it invisible to the undo mechanism (well, at least in terms of automatic undo)
It sets the NOMUTT variable to 0
It should be possible to share this command across others that have the need to call commands quietly
It uses the COM API to create an undo group around the operations we want to consider one "command"
The implementation related to the "quiet command calling" technique is wrapped up in a code region to make it easy to hide
One remaining - and, so far, unavoidable - piece of noise on the command-line is due to our use of the (handent) function: it echoes entity name of the selected dimension.
Here's the C# code:

2. using Autodesk.AutoCAD.ApplicationServices;
3. using Autodesk.AutoCAD.DatabaseServices;
4. using Autodesk.AutoCAD.EditorInput;
5. using Autodesk.AutoCAD.Runtime;
6. using Autodesk.AutoCAD.Interop;
7. namespace InspectDimension
8. {
9.   public class Commands
10.   {
11.     [CommandMethod("INSP")]
12.     static public void InspectDim()
13.     {
14.       Document doc =
15.         Application.DocumentManager.MdiActiveDocument;
16.       Database db = doc.Database;
17.       Editor ed = doc.Editor;
18.       PromptEntityOptions peo =
19.         new PromptEntityOptions("\nSelect a dimension: ");
20.       peo.SetRejectMessage(
21.         "\nEntity must be a dimension."
22.       );
23.       peo.AddAllowedClass(typeof(Dimension), false);
24.       PromptEntityResult per = ed.GetEntity(peo);
25.       if (per.Status != PromptStatus.OK)
26.         return;
27.       Transaction tr =
28.         db.TransactionManager.StartTransaction();
29.       using (tr)
30.       {
31.         Dimension dim =
32.           tr.GetObject(per.ObjectId, OpenMode.ForRead)
33.             as Dimension;
34.         if (dim != null)
35.         {
36.           string shape = "Round";
37.           string label = "myLabel";
38.           string rate = "100%";
39.           string cmd =
40.             "-DIMINSPECT Add (handent "" +
41.             dim.Handle + """ + ") \n" +
42.             shape + "\n" + label + "\n" +
43.             rate + "\n";
44.           SendQuietCommand(doc, cmd);
45.         };
46.         tr.Commit();
47.       }
48.     }
49.     #region QuietCommandCalling
50.     const string kFinishCmd = "FINISH_COMMAND";
51.     private static void SendQuietCommand(
52.       Document doc,
53.       string cmd
54.     )
55.     {
56.       // Get the old value of NOMUTT
57.       object nomutt =
58.         Application.GetSystemVariable("NOMUTT");
59.       // Add the string to reset NOMUTT afterwards
60.       AcadDocument oDoc =
61.         (AcadDocument)doc.AcadDocument;
62.       oDoc.StartUndoMark();
63.       cmd += "_" + kFinishCmd + " ";
64.       // Set NOMUTT to 1, reducing cmd-line noise
65.       Application.SetSystemVariable("NOMUTT", 1);
66.       doc.SendStringToExecute(cmd, true, false, false);
67.     }
68.     [CommandMethod(kFinishCmd, CommandFlags.NoUndoMarker)]
69.     static public void FinishCommand()
70.     {
71.       Document doc =
72.         Application.DocumentManager.MdiActiveDocument;
73.       AcadDocument oDoc =
74.         (AcadDocument)doc.AcadDocument;
75.       oDoc.EndUndoMark();
76.       Application.SetSystemVariable("NOMUTT", 0);
77.     }
78.     #endregion
79.   }
80. }

using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.Interop; namespace InspectDimension {   public class Commands   {     [CommandMethod("INSP")]     static public void InspectDim()     {       Document doc =         Application.DocumentManager.MdiActiveDocument;       Database db = doc.Database;       Editor ed = doc.Editor;       PromptEntityOptions peo =         new PromptEntityOptions("\nSelect a dimension: ");       peo.SetRejectMessage(         "\nEntity must be a dimension."       );       peo.AddAllowedClass(typeof(Dimension), false);       PromptEntityResult per = ed.GetEntity(peo);       if (per.Status != PromptStatus.OK)         return;       Transaction tr =         db.TransactionManager.StartTransaction();       using (tr)       {         Dimension dim =           tr.GetObject(per.ObjectId, OpenMode.ForRead)             as Dimension;         if (dim != null)         {           string shape = "Round";           string label = "myLabel";           string rate = "100%";           string cmd =             "-DIMINSPECT Add (handent "" +             dim.Handle + """ + ") \n" +             shape + "\n" + label + "\n" +             rate + "\n";           SendQuietCommand(doc, cmd);         };         tr.Commit();       }     }     #region QuietCommandCalling     const string kFinishCmd = "FINISH_COMMAND";     private static void SendQuietCommand(       Document doc,       string cmd     )     {       // Get the old value of NOMUTT       object nomutt =         Application.GetSystemVariable("NOMUTT");       // Add the string to reset NOMUTT afterwards       AcadDocument oDoc =         (AcadDocument)doc.AcadDocument;       oDoc.StartUndoMark();       cmd += "_" + kFinishCmd + " ";       // Set NOMUTT to 1, reducing cmd-line noise       Application.SetSystemVariable("NOMUTT", 1);       doc.SendStringToExecute(cmd, true, false, false);     }     [CommandMethod(kFinishCmd, CommandFlags.NoUndoMarker)]     static public void FinishCommand()     {       Document doc =         Application.DocumentManager.MdiActiveDocument;       AcadDocument oDoc =         (AcadDocument)doc.AcadDocument;       oDoc.EndUndoMark();       Application.SetSystemVariable("NOMUTT", 0);     }     #endregion   } }

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

1. Command: INSP
2. Select a dimension: <Entity name: -401f99f0>
3. Command:

复制代码

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


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

雪山飞狐_lzh

十三、防止的.NET模块被加载
September 08, 2008
Preventing a .NET module from being loaded by AutoCAD
This is an interesting one that came up recently during an internal discussion:
During my module's Initialize() function, I want to decide that the module should not actually be loaded. How can I accomplish that?
The answer is surprisingly simple: if you throw an exception during the function, AutoCAD's NETLOAD mechanism will stop loading the application.
For an example, see this C# code:

2. using Autodesk.AutoCAD.ApplicationServices;
3. using Autodesk.AutoCAD.EditorInput;
4. using Autodesk.AutoCAD.Runtime;
5. namespace PreventLoad
6. {
7.   public class Commands
8.   : IExtensionApplication
9.   {
10.     public void Initialize()
11.     {
12.       // This will prevent the application from loading
13.       throw new Exception();
14.     }
15.     public void Terminate(){}
16.     [CommandMethod("TEST")]
17.     static public void TestCommand()
18.     {
19.       Document doc =
20.         Application.DocumentManager.MdiActiveDocument;
21.       doc.Editor.WriteMessage(
22.         "\nThis should not get called."
23.       );
24.     }
25.   }
26. }

using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.Runtime; namespace PreventLoad {   public class Commands   : IExtensionApplication   {     public void Initialize()     {       // This will prevent the application from loading       throw new Exception();     }     public void Terminate(){}     [CommandMethod("TEST")]     static public void TestCommand()     {       Document doc =         Application.DocumentManager.MdiActiveDocument;       doc.Editor.WriteMessage(         "\nThis should not get called."       );     }   } }

Here's what happens when we attempt to load the application and then run the TEST command:

1. Command: FILEDIA
2. Enter new value for FILEDIA <1>: 0
3. Command: NETLOAD
4. Assembly file name: c:\MyApplication.dll
5. Command: TEST
6. Unknown command "TEST".  Press F1 for help.

复制代码

雪山飞狐_lzh

十四、使用代码载入.NET的模块
September 17, 2008
Loading .NET modules programmatically into AutoCAD
The question of how to perform a "NETLOAD" programmatically has come in a few times. Well, it turns out the answer - provided by someone in our Engineering team - is refreshingly simple.
The NETLOAD command actually has a bare-bones implementation: the hard work of parsing the metadata defining commands etc. is done from an AppDomain.AssemblyLoad event-handler. To recreate the NETLOAD command, all you need to do is call Assembly.LoadFrom(), passing in the path to your assembly.
Here's some C# code to demonstrate this:

2. using Autodesk.AutoCAD.ApplicationServices;
3. using Autodesk.AutoCAD.EditorInput;
4. using Autodesk.AutoCAD.Runtime;
5. using System.Reflection;
6. namespace LoadModule
7. {
8.   public class Commands
9.   {
10.     [CommandMethod("MNL")]
11.     static public void MyNetLoad()
12.     {
13.       Document doc =
14.         Application.DocumentManager.MdiActiveDocument;
15.       Editor ed = doc.Editor;
16.       PromptStringOptions pso =
17.         new PromptStringOptions(
18.           "\nEnter the path of the module to load: "
19.         );
20.       pso.AllowSpaces = true;
21.       PromptResult pr = ed.GetString(pso);
22.       if (pr.Status != PromptStatus.OK)
23.         return;
24.       try
25.       {
26.         Assembly.LoadFrom(pr.StringResult);
27.       }
28.       catch(System.Exception ex)
29.       {
30.         ed.WriteMessage(
31.           "\nCannot load {0}: {1}",
32.           pr.StringResult,
33.           ex.Message
34.         );
35.       }
36.     }
37.   }
38. }

using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.Runtime; using System.Reflection; namespace LoadModule {   public class Commands   {     [CommandMethod("MNL")]     static public void MyNetLoad()     {       Document doc =         Application.DocumentManager.MdiActiveDocument;       Editor ed = doc.Editor;       PromptStringOptions pso =         new PromptStringOptions(           "\nEnter the path of the module to load: "         );       pso.AllowSpaces = true;       PromptResult pr = ed.GetString(pso);       if (pr.Status != PromptStatus.OK)         return;       try       {         Assembly.LoadFrom(pr.StringResult);       }       catch(System.Exception ex)       {         ed.WriteMessage(           "\nCannot load {0}: {1}",           pr.StringResult,           ex.Message         );       }     }   } }

Incidentally, my preferred way to manage this is to enable demand loading for your assemblies, as per this previous post. But there are certainly situations where the above technique will prove useful.
In the next post: on Friday you should see the second installment of the interview with John Walker...

雪山飞狐_lzh

十五、自定义AutoCAD的命令显示在上下文菜单中
November 05, 2008
Displaying a context menu during a custom AutoCAD command using .NET
Some of you may have stumbled across these previous posts, which show how to add custom context menu items for specific object types and to the default AutoCAD context menu. There is a third way to create and display context menus inside AutoCAD, and this approach may prove useful to those of you who wish to display context menus during particular custom commands.One word of caution: I've been told that this technique does not currently work for transparent commands, so if your command needs to be called transparently then this may not be the approach for you (you should investigate asking for keywords, instead, as this should work without problem in this context).
Here's the C# code:

2. using Autodesk.AutoCAD.ApplicationServices;
3. using Autodesk.AutoCAD.EditorInput;
4. using Autodesk.AutoCAD.Runtime;
5. using Autodesk.AutoCAD.Windows;
6. using System;
7. namespace CommandContextMenu
8. {
9.   public class Commands
10.   {
11.     public class MyContextMenu : ContextMenuExtension
12.     {
13.       public MyContextMenu()
14.       {
15.         this.Title = "Command context menu";
16.         MenuItem mi = new MenuItem("Item One");
17.         mi.Click +=
18.           new EventHandler(Commands.OnClick);
19.         this.MenuItems.Add(mi);
20.         mi = new MenuItem("Item Two");
21.         mi.Click +=
22.           new EventHandler(Commands.OnClick);
23.         this.MenuItems.Add(mi);
24.         MenuItem smi = new MenuItem("Sub Item One");
25.         smi.Click +=
26.           new EventHandler(Commands.OnClick);
27.         this.MenuItems.Add(smi);
28.       }
29.     };
30.     [CommandMethod(
31.       "mygroup",
32.       "mycmd",
33.       null,
34.       CommandFlags.Modal,
35.       typeof(MyContextMenu)
36.     )]
37.     public static void MyCommand()
38.     {
39.       Editor ed =
40.         Application.DocumentManager.MdiActiveDocument.Editor;
41.       ed.GetPoint("\nRight-click before selecting a point:");
42.     }
43.     static void OnClick(object sender, EventArgs e)
44.     {
45.       Editor ed =
46.         Application.DocumentManager.MdiActiveDocument.Editor;
47.       ed.WriteMessage("\nA context menu item was selected.");
48.     }
49.   }
50. }

using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.Windows; using System; namespace CommandContextMenu {   public class Commands   {     public class MyContextMenu : ContextMenuExtension     {       public MyContextMenu()       {         this.Title = "Command context menu";         MenuItem mi = new MenuItem("Item One");         mi.Click +=           new EventHandler(Commands.OnClick);         this.MenuItems.Add(mi);         mi = new MenuItem("Item Two");         mi.Click +=           new EventHandler(Commands.OnClick);         this.MenuItems.Add(mi);         MenuItem smi = new MenuItem("Sub Item One");         smi.Click +=           new EventHandler(Commands.OnClick);         this.MenuItems.Add(smi);       }     };     [CommandMethod(       "mygroup",       "mycmd",       null,       CommandFlags.Modal,       typeof(MyContextMenu)     )]     public static void MyCommand()     {       Editor ed =         Application.DocumentManager.MdiActiveDocument.Editor;       ed.GetPoint("\nRight-click before selecting a point:");     }     static void OnClick(object sender, EventArgs e)     {       Editor ed =         Application.DocumentManager.MdiActiveDocument.Editor;       ed.WriteMessage("\nA context menu item was selected.");     }   } }

A couple of points about getting this working: on my system I used AutoCAD's OPTIONS command to make sure the right-click menu gets displayed after a certain delay (I enabled the option from the "User Preferences" -> "Right-Click Customization" and then changed the longer click duration to 100 milliseconds, to save a little time. :-)

The other option for enabling command menus is the SHORTCUTMENU system variable (the documentation inside AutoCAD will tell you about the various values).
Then, once inside the MYCMD command, I was able to right-click and see my custom menu:

From the command-line, we can see that our callback was called successfully:

1. Command:  MYCMD
2. Right-click before selecting a point:
3. A context menu item was selected.

复制代码

If you wish to have separate callbacks for your various items, it's simply a matter of defining separate functions and passing them in as the Click event handler instead of Command.OnClick.

雪山飞狐_lzh

十六、从外部引用导入层
May 18, 2009
Importing AutoCAD layers from xrefs using .NET
This post extends the last one which looked at a basic implementation to allow AutoCAD’s standard OFFSET command to work on the contents of external references. I haven’t flagged the specific changes, but the old code (which is almost identical to that in the last post) starts with the Initialize() function.
The previous example created geometry on a temporary layer that exists only as long as the source xref is attached: detaching the xref generally caused dangling layer references. This post evolves the approach and provides a choice to the user (via the XOFFSETLAYER command): to either create the geometry on the current layer (the default behaviour) or to clone across the layers, plus their various linetypes etc., needed for the geometry to survive independently of their originating xref.
I decided to put the code to copy across the layers in a separate command called XOFFSETCPLAYS, which has the advantage of being callable separately from our OFFSET routine (and is generally a bit safer – performing significant operations on AutoCAD databases from event handlers can lead to problems, depending on what exactly you’re doing). The command gets called using SendStringToExecute() so that it gets executed up after control has returned to the AutoCAD application.
The copying of symbol table records from xrefs is a little involved, but I’ve don what I can to comment the approach below. Using Database.wblockCloneObjects() is the cleanest approach, but there is work involved to load the xrefed DWGs into their own Database objects before using this.
Here’s the updated C# code:

2. using Autodesk.AutoCAD.ApplicationServices;
3. using Autodesk.AutoCAD.DatabaseServices;
4. using Autodesk.AutoCAD.EditorInput;
5. using Autodesk.AutoCAD.Runtime;
6. using System.Collections.Generic;
8. namespace XrefOffset
9. {
10.   public class XrefOffsetApplication : IExtensionApplication
11.   {
12.     // Maintain a list of temporary objects that require removal
14.     ObjectIdCollection _ids;
15.     static bool _placeOnCurrentLayer = true;
17.     public XrefOffsetApplication()
18.     {
19.       _ids = new ObjectIdCollection();
20.     }
22.     [CommandMethod("XOFFSETLAYER")]
23.     static public void XrefOffsetLayer()
24.     {
25.       Document doc =
26.         Application.DocumentManager.MdiActiveDocument;
27.       Database db = doc.Database;
28.       Editor ed = doc.Editor;
30.       PromptKeywordOptions pko =
31.         new PromptKeywordOptions(
32.           "\nEnter layer option for offset objects"
33.         );
34.       const string option1 = "Current";
35.       const string option2 = "Source";
37.       pko.AllowNone = true;
38.       pko.Keywords.Add(option1);
39.       pko.Keywords.Add(option2);
40.       pko.Keywords.Default =
41.         (_placeOnCurrentLayer ? option1 : option2);
43.       PromptResult pkr =
44.         ed.GetKeywords(pko);
46.       if (pkr.Status == PromptStatus.OK)
47.         _placeOnCurrentLayer =
48.           (pkr.StringResult == option1);
49.     }
51.     [CommandMethod("XOFFSETCPLAYS")]
52.     static public void XrefOffsetCopyLayers()
53.     {
54.       Document doc =
55.         Application.DocumentManager.MdiActiveDocument;
56.       Database db = doc.Database;
57.       Editor ed = doc.Editor;
59.       Transaction tr =
60.         doc.TransactionManager.StartTransaction();
61.       using (tr)
62.       {
63.         BlockTableRecord btr =
64.           (BlockTableRecord)tr.GetObject(
65.             db.CurrentSpaceId,
66.             OpenMode.ForRead
67.           );
69.         // We will collect the layers used by the various entities
71.         List<string> layerNames =
72.           new List<string>();
74.         // And store a list of the entities to come back and update
76.         ObjectIdCollection entsToUpdate =
77.           new ObjectIdCollection();
79.         // Loop through the contents of the active space, and look
80.         // for entities that are on dependent layers (i.e. ones
81.         // that come from attached xrefs)
83.         foreach (ObjectId entId in btr)
84.         {
85.           Entity ent =
86.             (Entity)tr.GetObject(entId, OpenMode.ForRead);
88.           // Check the dependent status of the entity's layer
90.           LayerTableRecord ltr =
91.             (LayerTableRecord)tr.GetObject(
92.               ent.LayerId,
93.               OpenMode.ForRead
94.             );
96.           if (ltr.IsDependent && !(ent is BlockReference))
97.           {
98.             // Add it to our list and flag the entity for updating
100.             string layName = ltr.Name;
101.             if (!layerNames.Contains(layName))
102.             {
103.               layerNames.Add(layName);
104.             }
105.             entsToUpdate.Add(ent.ObjectId);
106.           }
107.         }
108.         // Sorting the list will allow us to minimise the number
109.         // of external drawings we need to load (many layers
110.         // will be from the same xref)
112.         layerNames.Sort();
114.         // Get the xref graph, which allows us to get at the
115.         // names of the xrefed drawings more easily
117.         XrefGraph xg = db.GetHostDwgXrefGraph(false);
119.         // We're going to store a list of our xrefed databases
120.         // for later disposal
122.         List<Database> xrefs =
123.           new List<Database>();
125.         // Collect a list of the layers we want to clone across
127.         ObjectIdCollection laysToClone =
128.           new ObjectIdCollection();
130.         // Loop through the list of layers, only loading xrefs
131.         // in when they haven't been already
133.         string currentXrefName = "";
134.         foreach(string layName in layerNames)
135.         {
136.           Database xdb = null;
138.           // Make sure we have our mangled layer name
140.           if (layName.Contains("|"))
141.           {
142.             // Split it up, so we know the xref name
143.             // and the root layer name
145.             int sepIdx = layName.IndexOf("|");
146.             string xrefName =
147.               layName.Substring(0, sepIdx);
148.             string rootName =
149.               layName.Substring(sepIdx + 1);
151.             // If the xref is the same as the last loaded,
152.             // this saves us some effort
154.             if (xrefName == currentXrefName)
155.             {
156.               xdb = xrefs[xrefs.Count-1];
157.             }
158.             else
159.             {
160.               // Otherwise we get the node for our xref,
161.               // so we can get its filename
163.               XrefGraphNode xgn =
164.                 xg.GetXrefNode(xrefName);
166.               if (xgn != null)
167.               {
168.                 // Create an xrefed database, loading our
169.                 // drawing into it
171.                 xdb = new Database(false, true);
172.                 xdb.ReadDwgFile(
173.                   xgn.Database.Filename,
174.                   System.IO.FileShare.Read,
175.                   true,
176.                   null
177.                 );
179.                 // Add it to the list for later disposal
180.                 // (we do this after the clone operation)
182.                 xrefs.Add(xdb);
183.               }
184.               xgn.Dispose();
185.             }
187.             if (xdb != null)
188.             {
189.               // Start a transaction in our loaded database
190.               // to get at the layer name
192.               Transaction tr2 =
193.                 xdb.TransactionManager.StartTransaction();
194.               using (tr2)
195.               {
196.                 // Open the layer table
198.                 LayerTable lt2 =
199.                   (LayerTable)tr2.GetObject(
200.                     xdb.LayerTableId,
201.                     OpenMode.ForRead
202.                   );
204.                 // Add our layer (which we get via its
205.                 // unmangled name) to the list to clone
207.                 if (lt2.Has(rootName))
208.                 {
209.                   laysToClone.Add(lt2[rootName]);
210.                 }
212.                 // Committing is cheaper
214.                 tr2.Commit();
215.               }
216.             }
217.           }
218.         }
220.         // If we have layers to clone, do so
222.         if (laysToClone.Count > 0)
223.         {
224.           // We use wblockCloneObjects to clone between DWGs
226.           IdMapping idMap = new IdMapping();
227.           db.WblockCloneObjects(
228.             laysToClone,
229.             db.LayerTableId,
230.             idMap,
231.             DuplicateRecordCloning.Ignore,
232.             false
233.           );
235.           // Dispose each of our xrefed databases
237.           foreach (Database xdb in xrefs)
238.           {
239.             xdb.Dispose();
240.           }
242.           // Open the resultant layer table, so we can check
243.           // for the existance of our new layers
245.           LayerTable lt =
246.             (LayerTable)tr.GetObject(
247.               db.LayerTableId,
248.               OpenMode.ForRead
249.             );
251.           // Loop through the entities to update
253.           foreach (ObjectId id in entsToUpdate)
254.           {
255.             // Open them each for write, and then check their
256.             // current layer
258.             Entity ent =
259.               (Entity)tr.GetObject(id, OpenMode.ForWrite);
260.             LayerTableRecord ltr =
261.               (LayerTableRecord)tr.GetObject(
262.                 ent.LayerId,
263.                 OpenMode.ForRead
264.               );
266.             // We split the name once again (could use a function
267.             // for this, but hey)
269.             string layName = ltr.Name;
270.             int sepIdx = layName.IndexOf("|");
271.             string xrefName =
272.               layName.Substring(0, sepIdx);
273.             string rootName =
274.               layName.Substring(sepIdx + 1);
276.             // If we now have the layer in our database, use it
278.             if (lt.Has(rootName))
279.               ent.LayerId = lt[rootName];
280.           }
281.         }
282.         tr.Commit();
283.       }
284.     }
286.     public void Initialize()
287.     {
288.       DocumentCollection dm =
289.         Application.DocumentManager;
291.       // Remove any temporary objects at the end of the command
293.       dm.DocumentLockModeWillChange +=
294.         delegate(
295.           object sender, DocumentLockModeWillChangeEventArgs e
296.         )
297.         {
298.           if (_ids.Count > 0)
299.           {
300.             Transaction tr =
301.               e.Document.TransactionManager.StartTransaction();
302.             using (tr)
303.             {
304.               foreach (ObjectId id in _ids)
305.               {
306.                 DBObject obj =
307.                   tr.GetObject(id, OpenMode.ForWrite, true);
308.                 obj.Erase();
309.               }
310.               tr.Commit();
311.             }
312.             _ids.Clear();
314.             // Launch a command to bring across our layers
316.             if (!_placeOnCurrentLayer)
317.             {
318.               e.Document.SendStringToExecute(
319.                 "_.XOFFSETCPLAYS ", false, false, false
320.               );
321.             }
322.           }
323.         };
325.       // When a document is created, make sure we handle the
326.       // important events it fires
328.       dm.DocumentCreated +=
329.         delegate(
330.           object sender, DocumentCollectionEventArgs e
331.         )
332.         {
333.           e.Document.CommandWillStart +=
334.             new CommandEventHandler(OnCommandWillStart);
335.           e.Document.CommandEnded +=
336.             new CommandEventHandler(OnCommandFinished);
337.           e.Document.CommandCancelled +=
338.             new CommandEventHandler(OnCommandFinished);
339.           e.Document.CommandFailed +=
340.             new CommandEventHandler(OnCommandFinished);
341.         };
343.       // Do the same for any documents existing on application
344.       // initialization
346.       foreach (Document doc in dm)
347.       {
348.         doc.CommandWillStart +=
349.           new CommandEventHandler(OnCommandWillStart);
350.         doc.CommandEnded +=
351.           new CommandEventHandler(OnCommandFinished);
352.         doc.CommandCancelled +=
353.           new CommandEventHandler(OnCommandFinished);
354.         doc.CommandFailed +=
355.           new CommandEventHandler(OnCommandFinished);
356.       }
357.     }
359.     // When the OFFSET command starts, let's add our selection
360.     // manipulating event-handler
362.     void OnCommandWillStart(object sender, CommandEventArgs e)
363.     {
364.       if (e.GlobalCommandName == "OFFSET")
365.       {
366.         Document doc = (Document)sender;
367.         doc.Editor.PromptForEntityEnding +=
368.           new PromptForEntityEndingEventHandler(
369.             OnPromptForEntityEnding
370.           );
371.       }
372.     }
374.     // And when the command ends, remove it
376.     void OnCommandFinished(object sender, CommandEventArgs e)
377.     {
378.       if (e.GlobalCommandName == "OFFSET")
379.       {
380.         Document doc = (Document)sender;
381.         doc.Editor.PromptForEntityEnding -=
382.           new PromptForEntityEndingEventHandler(
383.             OnPromptForEntityEnding
384.           );
385.       }
386.     }
388.     // Here's where the heavy lifting happens...
390.     void OnPromptForEntityEnding(
391.       object sender, PromptForEntityEndingEventArgs e
392.     )
393.     {
394.       if (e.Result.Status == PromptStatus.OK)
395.       {
396.         Editor ed = sender as Editor;
397.         ObjectId objId = e.Result.ObjectId;
398.         Database db = objId.Database;
400.         Transaction tr =
401.           db.TransactionManager.StartTransaction();
402.         using (tr)
403.         {
404.           // First get the currently selected object
405.           // and check whether it's a block reference
407.           BlockReference br =
408.             tr.GetObject(objId, OpenMode.ForRead)
409.               as BlockReference;
410.           if (br != null)
411.           {
412.             // If so, we check whether the block table record
413.             // to which it refers is actually from an XRef
415.             ObjectId btrId = br.BlockTableRecord;
416.             BlockTableRecord btr =
417.               tr.GetObject(btrId, OpenMode.ForRead)
418.                 as BlockTableRecord;
419.             if (btr != null)
420.             {
421.               if (btr.IsFromExternalReference)
422.               {
423.                 // If so, then we programmatically select the object
424.                 // underneath the pick-point already used
426.                 PromptNestedEntityOptions pneo =
427.                   new PromptNestedEntityOptions("");
428.                 pneo.NonInteractivePickPoint =
429.                   e.Result.PickedPoint;
430.                 pneo.UseNonInteractivePickPoint = true;
432.                 PromptNestedEntityResult pner =
433.                   ed.GetNestedEntity(pneo);
435.                 if (pner.Status == PromptStatus.OK)
436.                 {
437.                   try
438.                   {
439.                     ObjectId selId = pner.ObjectId;
441.                     // Let's look at this programmatically-selected
442.                     // object, to see what it is
444.                     DBObject obj =
445.                       tr.GetObject(selId, OpenMode.ForRead);
447.                     // If it's a polyline vertex, we need to go one
448.                     // level up to the polyline itself
450.                     if (obj is PolylineVertex3d || obj is Vertex2d)
451.                       selId = obj.OwnerId;
453.                     // We don't want to do anything at all for
454.                     // textual stuff, let's also make sure we
455.                     // are dealing with an entity (should always
456.                     // be the case)
458.                     if (obj is MText || obj is DBText ||
459.                       !(obj is Entity))
460.                       return;
462.                     // Now let's get the name of the layer, to use
463.                     // later
465.                     Entity ent = (Entity)obj;
466.                     LayerTableRecord ltr =
467.                       (LayerTableRecord)tr.GetObject(
468.                         ent.LayerId,
469.                         OpenMode.ForRead
470.                       );
471.                     string layName = ltr.Name;
473.                     // Clone the selected object
475.                     object o = ent.Clone();
476.                     Entity clone = o as Entity;
478.                     // We need to manipulate the clone to make sure
479.                     // it works
481.                     if (clone != null)
482.                     {
483.                       // Setting the properties from the block
484.                       // reference helps certain entities get the
485.                       // right references (and allows them to be
486.                       // offset properly)
488.                       clone.SetPropertiesFrom(br);
490.                       // But we then need to get the layer
491.                       // information from the database to set the
492.                       // right layer (at least) on the new entity
494.                       if (_placeOnCurrentLayer)
495.                       {
496.                         clone.LayerId = db.Clayer;
497.                       }
498.                       else
499.                       {
500.                         LayerTable lt =
501.                           (LayerTable)tr.GetObject(
502.                             db.LayerTableId,
503.                             OpenMode.ForRead
504.                           );
505.                         if (lt.Has(layName))
506.                           clone.LayerId = lt[layName];
507.                       }
509.                       // Now we need to transform the entity for
510.                       // each of its Xref block reference containers
511.                       // If we don't do this then entities in nested
512.                       // Xrefs may end up in the wrong place
514.                       ObjectId[] conts =
515.                         pner.GetContainers();
516.                       foreach (ObjectId contId in conts)
517.                       {
518.                         BlockReference cont =
519.                           tr.GetObject(contId, OpenMode.ForRead)
520.                             as BlockReference;
521.                         if (cont != null)
522.                           clone.TransformBy(cont.BlockTransform);
523.                       }
525.                       // Let's add the cloned entity to the current
526.                       // space
528.                       BlockTableRecord space =
529.                         tr.GetObject(
530.                           db.CurrentSpaceId,
531.                           OpenMode.ForWrite
532.                         ) as BlockTableRecord;
533.                       if (space == null)
534.                       {
535.                         clone.Dispose();
536.                         return;
537.                       }
539.                       ObjectId cloneId = space.AppendEntity(clone);
540.                       tr.AddNewlyCreatedDBObject(clone, true);
542.                       // Now let's flush the graphics, to help our
543.                       // clone get displayed
545.                       tr.TransactionManager.QueueForGraphicsFlush();
547.                       // And we add our cloned entity to the list
548.                       // for deletion
550.                       _ids.Add(cloneId);
552.                       // Created a non-graphical selection of our
553.                       // newly created object and replace it with
554.                       // the selection of the container Xref
556.                       SelectedObject so =
557.                         new SelectedObject(
558.                           cloneId,
559.                           SelectionMethod.NonGraphical,
560.                           -1
561.                         );
563.                       e.ReplaceSelectedObject(so);
564.                     }
565.                   }
566.                   catch
567.                   {
568.                     // A number of innocuous things could go wrong
569.                     // so let's not worry about the details
571.                     // In the worst case we are simply not trying
572.                     // to replace the entity, so OFFSET will just
573.                     // reject the selected Xref
574.                   }
575.                 }
576.               }
577.             }
578.           }
579.           tr.Commit();
580.         }
581.       }
582.     }
584.     public void Terminate()
585.     {
586.     }
587.   }
588. }

using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.Runtime; using System.Collections.Generic; namespace XrefOffset {   public class XrefOffsetApplication : IExtensionApplication   {     // Maintain a list of temporary objects that require removal     ObjectIdCollection _ids;     static bool _placeOnCurrentLayer = true;     public XrefOffsetApplication()     {       _ids = new ObjectIdCollection();     }     [CommandMethod("XOFFSETLAYER")]     static public void XrefOffsetLayer()     {       Document doc =         Application.DocumentManager.MdiActiveDocument;       Database db = doc.Database;       Editor ed = doc.Editor;       PromptKeywordOptions pko =         new PromptKeywordOptions(           "\nEnter layer option for offset objects"         );       const string option1 = "Current";       const string option2 = "Source";       pko.AllowNone = true;       pko.Keywords.Add(option1);       pko.Keywords.Add(option2);       pko.Keywords.Default =         (_placeOnCurrentLayer ? option1 : option2);       PromptResult pkr =         ed.GetKeywords(pko);       if (pkr.Status == PromptStatus.OK)         _placeOnCurrentLayer =           (pkr.StringResult == option1);     }     [CommandMethod("XOFFSETCPLAYS")]     static public void XrefOffsetCopyLayers()     {       Document doc =         Application.DocumentManager.MdiActiveDocument;       Database db = doc.Database;       Editor ed = doc.Editor;       Transaction tr =         doc.TransactionManager.StartTransaction();       using (tr)       {         BlockTableRecord btr =           (BlockTableRecord)tr.GetObject(             db.CurrentSpaceId,             OpenMode.ForRead           );         // We will collect the layers used by the various entities         List<string> layerNames =           new List<string>();         // And store a list of the entities to come back and update         ObjectIdCollection entsToUpdate =           new ObjectIdCollection();         // Loop through the contents of the active space, and look         // for entities that are on dependent layers (i.e. ones         // that come from attached xrefs)         foreach (ObjectId entId in btr)         {           Entity ent =             (Entity)tr.GetObject(entId, OpenMode.ForRead);           // Check the dependent status of the entity's layer           LayerTableRecord ltr =             (LayerTableRecord)tr.GetObject(               ent.LayerId,               OpenMode.ForRead             );           if (ltr.IsDependent && !(ent is BlockReference))           {             // Add it to our list and flag the entity for updating             string layName = ltr.Name;             if (!layerNames.Contains(layName))             {               layerNames.Add(layName);             }             entsToUpdate.Add(ent.ObjectId);           }         }         // Sorting the list will allow us to minimise the number         // of external drawings we need to load (many layers         // will be from the same xref)         layerNames.Sort();         // Get the xref graph, which allows us to get at the         // names of the xrefed drawings more easily         XrefGraph xg = db.GetHostDwgXrefGraph(false);         // We're going to store a list of our xrefed databases         // for later disposal         List<Database> xrefs =           new List<Database>();         // Collect a list of the layers we want to clone across         ObjectIdCollection laysToClone =           new ObjectIdCollection();         // Loop through the list of layers, only loading xrefs         // in when they haven't been already         string currentXrefName = "";         foreach(string layName in layerNames)         {           Database xdb = null;           // Make sure we have our mangled layer name           if (layName.Contains("|"))           {             // Split it up, so we know the xref name             // and the root layer name             int sepIdx = layName.IndexOf("|");             string xrefName =               layName.Substring(0, sepIdx);             string rootName =               layName.Substring(sepIdx + 1);             // If the xref is the same as the last loaded,             // this saves us some effort             if (xrefName == currentXrefName)             {               xdb = xrefs[xrefs.Count-1];             }             else             {               // Otherwise we get the node for our xref,               // so we can get its filename               XrefGraphNode xgn =                 xg.GetXrefNode(xrefName);               if (xgn != null)               {                 // Create an xrefed database, loading our                 // drawing into it                 xdb = new Database(false, true);                 xdb.ReadDwgFile(                   xgn.Database.Filename,                   System.IO.FileShare.Read,                   true,                   null                 );                 // Add it to the list for later disposal                 // (we do this after the clone operation)                 xrefs.Add(xdb);               }               xgn.Dispose();             }             if (xdb != null)             {               // Start a transaction in our loaded database               // to get at the layer name               Transaction tr2 =                 xdb.TransactionManager.StartTransaction();               using (tr2)               {                 // Open the layer table                 LayerTable lt2 =                   (LayerTable)tr2.GetObject(                     xdb.LayerTableId,                     OpenMode.ForRead                   );                 // Add our layer (which we get via its                 // unmangled name) to the list to clone                 if (lt2.Has(rootName))                 {                   laysToClone.Add(lt2[rootName]);                 }                 // Committing is cheaper                 tr2.Commit();               }             }           }         }         // If we have layers to clone, do so         if (laysToClone.Count > 0)         {           // We use wblockCloneObjects to clone between DWGs           IdMapping idMap = new IdMapping();           db.WblockCloneObjects(             laysToClone,             db.LayerTableId,             idMap,             DuplicateRecordCloning.Ignore,             false           );           // Dispose each of our xrefed databases           foreach (Database xdb in xrefs)           {             xdb.Dispose();           }           // Open the resultant layer table, so we can check           // for the existance of our new layers           LayerTable lt =             (LayerTable)tr.GetObject(               db.LayerTableId,               OpenMode.ForRead             );           // Loop through the entities to update           foreach (ObjectId id in entsToUpdate)           {             // Open them each for write, and then check their             // current layer             Entity ent =               (Entity)tr.GetObject(id, OpenMode.ForWrite);             LayerTableRecord ltr =               (LayerTableRecord)tr.GetObject(                 ent.LayerId,                 OpenMode.ForRead               );             // We split the name once again (could use a function             // for this, but hey)             string layName = ltr.Name;             int sepIdx = layName.IndexOf("|");             string xrefName =               layName.Substring(0, sepIdx);             string rootName =               layName.Substring(sepIdx + 1);             // If we now have the layer in our database, use it             if (lt.Has(rootName))               ent.LayerId = lt[rootName];           }         }         tr.Commit();       }     }     public void Initialize()     {       DocumentCollection dm =         Application.DocumentManager;       // Remove any temporary objects at the end of the command       dm.DocumentLockModeWillChange +=         delegate(           object sender, DocumentLockModeWillChangeEventArgs e         )         {           if (_ids.Count > 0)           {             Transaction tr =               e.Document.TransactionManager.StartTransaction();             using (tr)             {               foreach (ObjectId id in _ids)               {                 DBObject obj =                   tr.GetObject(id, OpenMode.ForWrite, true);                 obj.Erase();               }               tr.Commit();             }             _ids.Clear();             // Launch a command to bring across our layers             if (!_placeOnCurrentLayer)             {               e.Document.SendStringToExecute(                 "_.XOFFSETCPLAYS ", false, false, false               );             }           }         };       // When a document is created, make sure we handle the       // important events it fires       dm.DocumentCreated +=         delegate(           object sender, DocumentCollectionEventArgs e         )         {           e.Document.CommandWillStart +=             new CommandEventHandler(OnCommandWillStart);           e.Document.CommandEnded +=             new CommandEventHandler(OnCommandFinished);           e.Document.CommandCancelled +=             new CommandEventHandler(OnCommandFinished);           e.Document.CommandFailed +=             new CommandEventHandler(OnCommandFinished);         };       // Do the same for any documents existing on application       // initialization       foreach (Document doc in dm)       {         doc.CommandWillStart +=           new CommandEventHandler(OnCommandWillStart);         doc.CommandEnded +=           new CommandEventHandler(OnCommandFinished);         doc.CommandCancelled +=           new CommandEventHandler(OnCommandFinished);         doc.CommandFailed +=           new CommandEventHandler(OnCommandFinished);       }     }     // When the OFFSET command starts, let's add our selection     // manipulating event-handler     void OnCommandWillStart(object sender, CommandEventArgs e)     {       if (e.GlobalCommandName == "OFFSET")       {         Document doc = (Document)sender;         doc.Editor.PromptForEntityEnding +=           new PromptForEntityEndingEventHandler(             OnPromptForEntityEnding           );       }     }     // And when the command ends, remove it     void OnCommandFinished(object sender, CommandEventArgs e)     {       if (e.GlobalCommandName == "OFFSET")       {         Document doc = (Document)sender;         doc.Editor.PromptForEntityEnding -=           new PromptForEntityEndingEventHandler(             OnPromptForEntityEnding           );       }     }     // Here's where the heavy lifting happens...     void OnPromptForEntityEnding(       object sender, PromptForEntityEndingEventArgs e     )     {       if (e.Result.Status == PromptStatus.OK)       {         Editor ed = sender as Editor;         ObjectId objId = e.Result.ObjectId;         Database db = objId.Database;         Transaction tr =           db.TransactionManager.StartTransaction();         using (tr)         {           // First get the currently selected object           // and check whether it's a block reference           BlockReference br =             tr.GetObject(objId, OpenMode.ForRead)               as BlockReference;           if (br != null)           {             // If so, we check whether the block table record             // to which it refers is actually from an XRef             ObjectId btrId = br.BlockTableRecord;             BlockTableRecord btr =               tr.GetObject(btrId, OpenMode.ForRead)                 as BlockTableRecord;             if (btr != null)             {               if (btr.IsFromExternalReference)               {                 // If so, then we programmatically select the object                 // underneath the pick-point already used                 PromptNestedEntityOptions pneo =                   new PromptNestedEntityOptions("");                 pneo.NonInteractivePickPoint =                   e.Result.PickedPoint;                 pneo.UseNonInteractivePickPoint = true;                 PromptNestedEntityResult pner =                   ed.GetNestedEntity(pneo);                 if (pner.Status == PromptStatus.OK)                 {                   try                   {                     ObjectId selId = pner.ObjectId;                     // Let's look at this programmatically-selected                     // object, to see what it is                     DBObject obj =                       tr.GetObject(selId, OpenMode.ForRead);                     // If it's a polyline vertex, we need to go one                     // level up to the polyline itself                     if (obj is PolylineVertex3d || obj is Vertex2d)                       selId = obj.OwnerId;                     // We don't want to do anything at all for                     // textual stuff, let's also make sure we                     // are dealing with an entity (should always                     // be the case)                     if (obj is MText || obj is DBText ||                       !(obj is Entity))                       return;                     // Now let's get the name of the layer, to use                     // later                     Entity ent = (Entity)obj;                     LayerTableRecord ltr =                       (LayerTableRecord)tr.GetObject(                         ent.LayerId,                         OpenMode.ForRead                       );                     string layName = ltr.Name;                     // Clone the selected object                     object o = ent.Clone();                     Entity clone = o as Entity;                     // We need to manipulate the clone to make sure                     // it works                     if (clone != null)                     {                       // Setting the properties from the block                       // reference helps certain entities get the                       // right references (and allows them to be                       // offset properly)                       clone.SetPropertiesFrom(br);                       // But we then need to get the layer                       // information from the database to set the                       // right layer (at least) on the new entity                       if (_placeOnCurrentLayer)                       {                         clone.LayerId = db.Clayer;                       }                       else                       {                         LayerTable lt =                           (LayerTable)tr.GetObject(                             db.LayerTableId,                             OpenMode.ForRead                           );                         if (lt.Has(layName))                           clone.LayerId = lt[layName];                       }                       // Now we need to transform the entity for                       // each of its Xref block reference containers                       // If we don't do this then entities in nested                       // Xrefs may end up in the wrong place                       ObjectId[] conts =                         pner.GetContainers();                       foreach (ObjectId contId in conts)                       {                         BlockReference cont =                           tr.GetObject(contId, OpenMode.ForRead)                             as BlockReference;                         if (cont != null)                           clone.TransformBy(cont.BlockTransform);                       }                       // Let's add the cloned entity to the current                       // space                       BlockTableRecord space =                         tr.GetObject(                           db.CurrentSpaceId,                           OpenMode.ForWrite                         ) as BlockTableRecord;                       if (space == null)                       {                         clone.Dispose();                         return;                       }                       ObjectId cloneId = space.AppendEntity(clone);                       tr.AddNewlyCreatedDBObject(clone, true);                       // Now let's flush the graphics, to help our                       // clone get displayed                       tr.TransactionManager.QueueForGraphicsFlush();                       // And we add our cloned entity to the list                       // for deletion                       _ids.Add(cloneId);                       // Created a non-graphical selection of our                       // newly created object and replace it with                       // the selection of the container Xref                       SelectedObject so =                         new SelectedObject(                           cloneId,                           SelectionMethod.NonGraphical,                           -1                         );                       e.ReplaceSelectedObject(so);                     }                   }                   catch                   {                     // A number of innocuous things could go wrong                     // so let's not worry about the details                     // In the worst case we are simply not trying                     // to replace the entity, so OFFSET will just                     // reject the selected Xref                   }                 }               }             }           }           tr.Commit();         }       }     }     public void Terminate()     {     }   } }

Depending on the mode selected, the results should be comparable with those from the code in the last post.
Here’s a portion of an xref:

Here are the results of using OFFSET on some of the xref’s contents after loading our module (to get these results you would also need to use XOFFSETLAYER to make sure the original layers get copied across):

Update:
I’ve modified the implementation of the XOFFSETLAYER command to be consistent with the prompts in the OFFSET command (under the Layer option – not sure how I missed that one :-). The ideal would have been to access that setting directly, but that doesn’t seem to be possible, as far as I can tell.

雪山飞狐_lzh

July 10, 2006
Calling ObjectARX functions from a .NET application

One of the really compelling features of .NET is its ability to call "legacy" unmanaged C++ APIs. I say "legacy", but we use this facility regularly to call APIs that are far from being considered defunct (the C++ version of ObjectARX is alive and kicking, believe me! :-).

Autodesk understands that our development partners have invested many years in application development, and can't afford to throw that investment away to support the latest & greatest (and sometimes "flavor of the month") programming technology. For example, over the years we've made sure it was possible to create a VB or VBA user-interface for an existing LISP application or now a .NET user-interface for an ObjectARX application. Sometimes we expose our own interoperability functions to help with this (such as LISP functions to call ActiveX DLLs), and in other cases we advise people on how best to leverage standard Microsoft platform technologies.

So... how do you call an ObjectARX function from VB.NET? The answer is Platform Invoke (or P/Invoke for short). Microsoft has not exposed the full functionality of the Win32 API through the .NET Framework - just as Autodesk has not exposed all of ObjectARX through AutoCAD's Managed API - but P/Invoke helps you get around this.

First, some background on what ObjectARX really is, and how P/Invoke can help us.

ObjectARX is a set of APIs that are exported from DLLs or EXEs. Most exported functions get "decorated" or "mangled" during compilation, unless there is a specific compiler directive not to (this is the case for all the old ADS functions, for instance - they are declared as extern "C" and are therefore not mangled). The compiler assigns a unique name based on the function signature, which makes sense: it is quite legal in C++ to have two functions with the same name, but not with identical arguments and return values. The decorated name includes the full function name inside it, which is why the below technique for finding the correct export works.

[ Note: this technique works well for C-style functions, or C++ static functions. It will not work on instance members (methods of classes), as it is not possible to instantiate an unmanaged object of the class that defines the class from managed code. If you need to expose a class method to managed code, you will need to write & expose some native C++ code that instantiates the class, calls the method and returns the result. ]

To demonstrate the procedure we're going to work through the steps needed to call acedGetUserFavoritesDir() from C# and VB.NET. This function is declared in the ObjectARX headers as:

    extern Adesk::Boolean acedGetUserFavoritesDir( ACHAR* szFavoritesDir );

According to the ObjectARX Reference, "this function provides access to the Windows Favorites directory of the current user."

Step 1 - Identify the location of the export.

Fenton Webb, from DevTech EMEA, provided this handy batch file he uses for just this purpose:

[ Copy and paste this into a file named "findapi.bat", which you then place this into your AutoCAD application folder. You will need to run findapi from a command prompt which knows where to find dumpbin.exe - the Visual Studio Command Prompts created on installing VS will help you with this. ]

    @echo off
    if "%1" == "" goto usage
    :normal
    for %%i IN (*.exe *.dll *.arx *.dbx *.ocx *.ddf) DO dumpbin /exports %%i | findstr "%%i %1"
    goto end
    :usage
    echo findapi "function name"
    :end

You can redirect the output into a text file, of course, for example:

    C:\Program Files\AutoCAD 2007>findapi acedGetUserFavoritesDir > results.txt

It'll take some time to work, as this batch file chunks through all the DLLs, EXEs, etc. in the AutoCAD application folder to find the results (it doesn't stop when it finds one, either - this enhancement is left as an exercise for the reader ;-).

Opening the text file will allow you to see where the acedGetUserFavoritesDir() function is exported:

[ from the results for AutoCAD 2007 ]

    Dump of file acad.exe
            436  1B0 004B4DC0 ?acedGetUserFavoritesDir@@YAHPA_W@Z

A word of warning: the decorated names for functions accepting/returning strings changed between AutoCAD 2006 and 2007, because we are now using Unicode for string definition. Here is the previous declaration for 2004/2005/2006 (which was probably valid for as long as the function was defined, back in AutoCAD 2000i, if I recall correctly):

[ from the results for AutoCAD 2006 ]

    Dump of file acad.exe
            357  161 00335140 ?acedGetUserFavoritesDir@@YAHPAD@Z

This is simply because the function signature has changed from taking a char* to an ACHAR* (a datatype which now resolves to a "wide" or Unicode string in AutoCAD 2007). A change in the function signature results in a change in the decorated name. This is straightforward enough, but it is worth bearing in mind the potential migration issue - a heavy dependency on decorated function names can lead to substantial migration effort if widespread signature changes are made in a release (as with AutoCAD 2007's support of Unicode).

Another warning: you will find a number of other functions exported from the various DLLs/EXEs that do not have corresponding declarations in the ObjectARX headers. These functions - while exposed - are not supported. Which means that you may be able to work out how they can be called, but use them at your own risk (which can be substantial). Unsupported APIs are liable to change (or even disappear) without notice.

Now we've identified where and how the function is exposed, we can create a declaration of this function we can use in our code.

Step 2 - Declare the function correctly in your code.

This is going to be slightly different depending on the programming language you're using.

VB developers will be used to using "Declare" to set-up P/Invoke from their projects. This ends up being translated by the compiler into calls to DllImport, which is also used directly in C#.

These declarations should be made at the class level (not within an individual function definition).

VB.NET

    Private Declare Auto Function acedGetUserFavoritesDir Lib "acad.exe" Alias "?acedGetUserFavoritesDir@@YAHPA_W@Z" (<MarshalAs(UnmanagedType.LPWStr)> ByVal sDir As StringBuilder) As Boolean

C#

    [DllImport("acad.exe", EntryPoint = "?acedGetUserFavoritesDir@@YAHPA_W@Z", CharSet = CharSet.Auto)]
    public static extern bool acedGetUserFavoritesDir([MarshalAs(UnmanagedType.LPWStr)] StringBuilder sDir);

Notes:

   1. It's worth specifying the character set as "Auto" - which is not the default setting. The compiler does a good job of working out whether to use Unicode or ANSI, so it's easiest to trust it to take care of this.
   2. You will need to use the MarshalAs(UnmanagedType.LPWStr) declaration for Unicode string variables in 2007. This is true whether using Strings or StringBuilders.
   3. Use a StringBuilder for an output string parameter, as standard Strings are considered immutable. Strings are fine for input parameters.

Step 3 - Use the function in your code

[ I've omited the standard using/import statements, as well as the class & function declarations, to improve readability. ]

VB.NET

    Dim ed As Editor = Application.DocumentManager.MdiActiveDocument.Editor
    Dim sDir As New StringBuilder(256)
    Dim bRet As Boolean = acedGetUserFavoritesDir(sDir)
    If bRet And sDir.Length > 0 Then
            ed.WriteMessage("Your favorites folder is: " + sDir.ToString)
    End If

C#

    Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
    StringBuilder sDir = new StringBuilder(256);
    bool bRet = acedGetUserFavoritesDir(sDir);
    if (bRet && sDir.Length > 0)
            ed.WriteMessage("Your favorites folder is: " + sDir.ToString());

Note: we declare the StringBuilder variable (sDir) as being 256 characters long. AutoCAD expects us to provide a sufficiently long buffer for the data to be copied into it.

On my system both code snippets resulted in the following being sent to AutoCAD's command-line:

    Your favorites folder is: C:\My Documents\Favorites

So that's it: you should now be able to call global ObjectARX functions from .NET. This technique can also be used to call your own functions exposed from DLLs... which is one way to allow you to create fancy UIs with .NET and leverage existing C++ code (there are others, such as exposing your own Managed API).

For additional information on using P/Invoke, particularly with Win32, here is a really great resource.

http://pinvoke.net/