The "Double Click Actions" part in CUIX can be manually or programmatically modified according to the need. This makes it very easy to customize Double Click Actions differently from the default actions. With this approach, only one action (command) can be associated to each type of Entity. While in reality, however, we might want AutoCAD to act differently when user double-clicks the same types of entities. For example, when a line is double-clicked, we may want to do one thing, depending on some conditions and do other thing under different condition; if a block is double-clicked, depending on its name or its attributes, we may want to present different dialog boxes; and so on.
There is long thread of discussion on this topic in AutoCAD discussion forum here. Based on the discussion, Balaji Ramamoorthy posted a solution, which places some logic in the command that associated with "Double Click Actions" in the CUI/CUIX, so that the actual action taken against the selected entity or entities could be different, depending on particular conditions.
Be aware that the solution for custom double-click action based on modifying "Double Click Actions" in CUI/CUIX has a pre-condition: the system variable "DBLCLKEDIT" must be set to 1. If for any reason this system variable is set to 0, all the double-click actions defined in the CUI/CUIX will stop work. Also, changing CUI/CUIX (and saving the changes) with code may not be preferred in some tightly managed drafting environment.
Here I post code samples that uses Application.BeginDoubleClick event handler to realize desired custom double-click actions.
Up to AutoCAD 2009, there is no Application.BeginDoubleClick event exposed in AutoCAD's .NET API. Well, with AutoCAD's COM API does expose a AcadDocument.BeginDoubleClick event, but because there is lack of means to suppress the default double-click action (defined in the CUI/CUIX), thus, the COM API's BeginDoubleClick event does not help in term of doing custom double-click action.
The thoughts of using Application.BeginDoubleClick event to do our own custom double-click actions is like this:
1. Application.BeginDoubleClick event always fires, regardless the value of system variable "DBLCLKEDIT". That means we can guarantee that our own custom double-click action will work as we want;
2. When Application.BegnDoubleClick event fires, we can get the entity or entities selected by the double-click and apply some logic against the entity or entities to determine if we want to let default double-click action do its work, or let particular custom double-click action do its work; If the logic decides that a custom double-click action should be used, then we use DocumentLockModeChanged event handler to veto the default double-click action and use DocumentLockModeChangeVetoed event handler to launch the desired custom double-click action.
With these thoughts in mind, I worked out some code posted here.
Firstly, I need something that can be used to determine if a custom command would be used when Application.BeginDoubleClick event fires. The available information for making the decision is ObjectId of the selected entity. So, I create an Interface like this:
1 using Autodesk.AutoCAD.DatabaseServices;
2
3 namespace DoubleClickHandler
4 {
5 public interface ICustomCommandMapper
6 {
7 string GetMappedCustomCommand(ObjectId entId);
8 }
9 }
Then I implement this interface for each targeting entity type (just like how is "Double Click Actions" in CUI/CUIX defined for each entity type). In the sample project, I only implemented this interface for 2 types of entity: Line and BlockReference. See code below:
1 using System;
2 using System.Collections.Generic;
3 using Autodesk.AutoCAD.DatabaseServices;
4 using Autodesk.AutoCAD.Geometry;
5 using Autodesk.AutoCAD.Runtime;
6
7 namespace DoubleClickHandler
8 {
9 public class LineCustomCommandMapper : ICustomCommandMapper
10 {
11 private Type _entityType;
12 private RXClass _rxClass;
13
14 public LineCustomCommandMapper()
15 {
16 _entityType = typeof(Line);
17 _rxClass = RXClass.GetClass(_entityType);
18 }
19
20 public Type EntityType
21 {
22 get { return _entityType; }
23 }
24
25 public string GetMappedCustomCommand(ObjectId entId)
26 {
27 if (entId.ObjectClass != _rxClass) return null;
28
29 //Do something based on the ObjectId. For example:
30 //if the entity has XData attached, the attached
31 //data may decide what command to use
32
33 //Here I use simply use Line's geometric info:
34 //If the line is drawn from left to right, or
35 //from right to left
36 Point3d sPt;
37 Point3d ePt;
38 Database db = entId.Database;
39 using (Transaction tran =
40 db.TransactionManager.StartOpenCloseTransaction())
41 {
42 Line line = (Line)tran.GetObject(entId, OpenMode.ForRead);
43 sPt = line.StartPoint;
44 ePt = line.EndPoint;
45 tran.Commit();
46 }
47
48 if (sPt.X < ePt.X)
49 return "MyLineEditCommand1";
50 else
51 return "MyLineEditCommand2";
52 }
53 }
54
55 public class BlockCustomCommandMapper : ICustomCommandMapper
56 {
57 private Type _entityType;
58 private RXClass _rxClass;
59 private Dictionary<string, string> _dicCommands;
60
61 public BlockCustomCommandMapper(Dictionary<string, string> blkEditCommands)
62 {
63 _entityType = typeof(BlockReference);
64 _rxClass = RXClass.GetClass(_entityType);
65 _dicCommands = blkEditCommands;
66 }
67
68 public Type EntityType
69 {
70 get { return _entityType; }
71 }
72
73 public string GetMappedCustomCommand(ObjectId entId)
74 {
75 if (entId.ObjectClass != _rxClass) return null;
76
77 //Do something based on the ObjectId. For example:
78 //if the entity has XData attached, tne attached
79 //data may decide what command to use
80
81 //As for block, different command usually is chosen
82 //based on different block name
83 string bName = GetBlockName(entId);
84
85 if (_dicCommands.ContainsKey(bName.ToUpper()))
86 {
87 return _dicCommands[bName.ToUpper()];
88 }
89
90 return null;
91 }
92
93 private static string GetBlockName(ObjectId entId)
94 {
95 string blkName = "";
96
97 using (Transaction tran =
98 entId.Database.TransactionManager.StartOpenCloseTransaction())
99 {
100 BlockReference bref = (BlockReference)
101 tran.GetObject(entId, OpenMode.ForRead);
102
103 if (bref.IsDynamicBlock)
104 {
105 if (bref.Name.StartsWith("*"))
106 {
107 BlockTableRecord br = (BlockTableRecord)
108 tran.GetObject(bref.DynamicBlockTableRecord, OpenMode.ForRead);
109 blkName = br.Name;
110 }
111 else
112 {
113 blkName = bref.Name;
114 }
115 }
116 else
117 {
118 blkName = bref.Name;
119 }
120
121 tran.Commit();
122 }
123
124 return blkName;
125 }
126 }
127 }
From these 2 ICustomCommandMapper classes one can see there is literally no limit how many custom commands can come out the method GetMappedCustomCommand(), depending on what operation one want to apply to the target type of entity. Take BlockReference as an example: it is very practical that we may want to show different dialog box for editing block and/or block attribute, if the selected block has different name.
Of course, corresponding to the custom commands that are returned by the GetMappedCustomCommand(), I have following command methods that mimic different custom actions (showing different messages in message box):
1 using Autodesk.AutoCAD.ApplicationServices;
2 using Autodesk.AutoCAD.DatabaseServices;
3 using Autodesk.AutoCAD.EditorInput;
4 using Autodesk.AutoCAD.Runtime;
5
6 [assembly: CommandClass(typeof(DoubleClickHandler.CustomCommands))]
7
8 namespace DoubleClickHandler
9 {
10 public class CustomCommands
11 {
12 #region Commands for LineCustomCommandMapper
13
14 [CommandMethod("MyLineEditCommand1", CommandFlags.UsePickSet)]
15 public void RunMyLineEditCommand1()
16 {
17 ObjectId entId = GetSelectedEntity();
18 if (entId == ObjectId.Null) return;
19
20 string msg =
21 "This is a dialog box for editing LINE entity drawn from left to right." +
22 "\n\nEntity Id=" + entId.ToString();
23 Application.ShowAlertDialog(msg);
24 }
25
26 [CommandMethod("MyLineEditCommand2", CommandFlags.UsePickSet)]
27 public void RunMyLineEditCommand2()
28 {
29 ObjectId entId = GetSelectedEntity();
30 if (entId == ObjectId.Null) return;
31
32 string msg =
33 "This is a dialog box for editing LINE entity drawn from right to left." +
34 "\n\nEntity Id=" + entId.ToString();
35 Application.ShowAlertDialog(msg);
36 }
37
38 #endregion
39
40 #region Commands for BlockCustomCommandMapper
41
42 [CommandMethod("BlockEditCommand1", CommandFlags.UsePickSet)]
43 public void RunBlockEditCommand1()
44 {
45 ObjectId entId = GetSelectedEntity();
46 if (entId == ObjectId.Null) return;
47
48 string msg = "This is a dialog box for editing block \"TestBlock1\"." +
49 "\n\nEntity Id=" + entId.ToString();
50 Application.ShowAlertDialog(msg);
51 }
52
53 [CommandMethod("BlockEditCommand2", CommandFlags.UsePickSet)]
54 public void RunBlockEditCommand2()
55 {
56 ObjectId entId = GetSelectedEntity();
57 if (entId == ObjectId.Null) return;
58
59 string msg = "This is a dialog box for editing block \"TestBlock2\"." +
60 "\n\nEntity Id=" + entId.ToString();
61 Application.ShowAlertDialog(msg);
62 }
63
64 #endregion
65
66 #region private methods
67
68 private ObjectId GetSelectedEntity()
69 {
70 Editor ed=Application.DocumentManager.MdiActiveDocument.Editor;
71 PromptSelectionResult res = ed.GetSelection();
72
73 if (res.Status == PromptStatus.OK)
74 {
75 return res.Value.GetObjectIds()[0];
76 }
77 else
78 {
79 return ObjectId.Null;
80 }
81 }
82
83 #endregion
84 }
85 }
In order to use the ICustumCommandMapper classes easily, I also created a CustomCommandMappers collection, derived from Dictionary
1 using System;
2 using System.Collections.Generic;
3 using Autodesk.AutoCAD.DatabaseServices;
4
5 namespace DoubleClickHandler
6 {
7 public class CustomCommandMappers : Dictionary<Type, ICustomCommandMapper>
8 {
9 public string GetCustomCommand(ObjectId entId)
10 {
11 string cmd = null;
12
13 foreach (KeyValuePair<Type, ICustomCommandMapper> item in this)
14 {
15 ICustomCommandMapper custCommand = item.Value;
16 string c = custCommand.GetMappedCustomCommand(entId);
17 if (!string.IsNullOrEmpty(c))
18 {
19 cmd = c;
20 break;
21 }
22 }
23
24 return cmd;
25 }
26 }
27
28 public class CustomCommandsFactory
29 {
30 public static CustomCommandMappers CreateDefaultCustomCommandMappers()
31 {
32 CustomCommandMappers cmds = new CustomCommandMappers();
33
34 //Manually create 2 instances of ICustomCOmmandMapper object
35 //for demo purpose
36 ICustomCommandMapper cmd;
37
38 cmd = new LineCustomCommandMapper();
39 cmds.Add(typeof(Line), cmd);
40
41 Dictionary<string, string> dic = new Dictionary<string, string>();
42 dic.Add("TESTBLOCK1", "BlockEditCommand1");
43 dic.Add("TESTBLOCK2", "BlockEditCommand2");
44 cmd = new BlockCustomCommandMapper(dic);
45 cmds.Add(typeof(BlockReference), cmd);
46
47 return cmds;
48 }
49
50 public static CustomCommandMappers CreateCustomCommandMappersFromSettings()
51 {
52 //We can define information required by ICustomCommandMapper
53 //in some sort of configurable application settings, such as acad.exe.config,
54 //and implement this method to loaded it.
55 throw new NotImplementedException("This method is not implemented.");
56 }
57 }
58 }
Now it comes to the centre piece of the code - actually handling the Application.BeginDoubleClick to let AutoCAD intelligently launch default Double Click Action defined in CUI/CUIX or launch our custom action, even with system variable "DBLCLKEDIT" is disabled:
1 using Autodesk.AutoCAD.ApplicationServices;
2 using Autodesk.AutoCAD.DatabaseServices;
3 using Autodesk.AutoCAD.EditorInput;
4 using Autodesk.AutoCAD.Runtime;
5
6 [assembly: CommandClass(typeof(DoubleClickHandler.AppDoubleClickHandler))]
7 [assembly: ExtensionApplication(typeof(DoubleClickHandler.AppDoubleClickHandler))]
8
9 namespace DoubleClickHandler
10 {
11 public class AppDoubleClickHandler : IExtensionApplication
12 {
13 private static bool _handlerLoaded = false;
14 private static string _customCmd = null;
15 private static ObjectId _selectedEntId = ObjectId.Null;
16 private static CustomCommandMappers _customCommands = null;
17 private static bool _runCustomCommand = false;
18
19 public void Initialize()
20 {
21 Document dwg = Application.DocumentManager.MdiActiveDocument;
22 Editor ed = dwg.Editor;
23
24 try
25 {
26 ed.WriteMessage("\nInitializing {0}...", this.GetType().Name);
27
28 AddDoubleClickHandler();
29
30 ed.WriteMessage("completed\n");
31
32 ed.WriteMessage("\nMy Double-Click Handler has been turned {0}.",
33 _handlerLoaded ? "on" : "off");
34 Autodesk.AutoCAD.Internal.Utils.PostCommandPrompt();
35 }
36 catch (System.Exception ex)
37 {
38 ed.WriteMessage("failed:\n{0}", ex.ToString());
39 }
40 }
41
42 public void Terminate()
43 {
44
45 }
46
47 //Command to toggle this Double-Click handler on or off
48 [CommandMethod("MyDblClick", CommandFlags.Session)]
49 public static void ToggleDoubleClickHandling()
50 {
51 Document dwg = Application.DocumentManager.MdiActiveDocument;
52 Editor ed = dwg.Editor;
53
54 PromptKeywordOptions opt = new PromptKeywordOptions(
55 "\nToggle My Double-Click Handler on/off");
56 opt.Keywords.Add("oN");
57 opt.Keywords.Add("oFf");
58 opt.Keywords.Default = _handlerLoaded ? "oN" : "oFf";
59 opt.AppendKeywordsToMessage = true;
60 PromptResult res = ed.GetKeywords(opt);
61 if (res.StringResult.ToUpper() == "ON")
62 AddDoubleClickHandler();
63 else
64 RemoveDoubleClickHandler();
65
66 ed.WriteMessage("\nMy Double-Click Handler has been turned {0}.",
67 _handlerLoaded?"on":"off");
68 Autodesk.AutoCAD.Internal.Utils.PostCommandPrompt();
69 }
70
71 #region private methods
72
73 private static void AddDoubleClickHandler()
74 {
75 if (_handlerLoaded) return;
76
77 Application.BeginDoubleClick += Application_BeginDoubleClick;
78 Application.DocumentManager.DocumentLockModeChanged +=
79 DocumentManager_DocumentLockModeChanged;
80 Application.DocumentManager.DocumentLockModeChangeVetoed +=
81 DocumentManager_DocumentLockModeChangeVetoed;
82 _handlerLoaded = true;
83
84 //Load custom command mappers
85 if (_customCommands == null) _customCommands =
86 CustomCommandsFactory.CreateDefaultCustomCommandMappers();
87 }
88
89 private static void RemoveDoubleClickHandler()
90 {
91 if (!_handlerLoaded) return;
92
93 Application.BeginDoubleClick -= Application_BeginDoubleClick;
94 Application.DocumentManager.DocumentLockModeChanged -=
95 DocumentManager_DocumentLockModeChanged;
96 Application.DocumentManager.DocumentLockModeChangeVetoed -=
97 DocumentManager_DocumentLockModeChangeVetoed;
98
99 _customCommands = null;
100
101 _handlerLoaded = false;
102 }
103
104 private static void Application_BeginDoubleClick(
105 object sender, BeginDoubleClickEventArgs e)
106 {
107 _customCmd = null;
108 _selectedEntId = ObjectId.Null;
109
110 //Get entity which user double-clicked on
111 Editor ed=Application.DocumentManager.MdiActiveDocument.Editor;
112 PromptSelectionResult res = ed.SelectImplied();
113 if (res.Status == PromptStatus.OK)
114 {
115 ObjectId[] ids = res.Value.GetObjectIds();
116
117 //Only when there is one entity selected, we go ahead to see
118 //if there is a custom command supposed to target at this entity
119 if (ids.Length == 1)
120 {
121 //Find mapped custom command name
122 string cmd = _customCommands.GetCustomCommand(ids[0]);
123 if (!string.IsNullOrEmpty(cmd))
124 {
125 _selectedEntId = ids[0];
126 _customCmd = cmd;
127
128 ed.WriteMessage("\nRun command {0} agianst entity {1}",
129 _customCmd, _selectedEntId.ToString());
130
131 if (System.Convert.ToInt32(
132 Application.GetSystemVariable("DBLCLKEDIT")) == 0)
133 {
134 //Since "Double click editing" is not enabled, we'll
135 //go ahead to launch our custom command
136 LaunchCustomCommand(ed);
137 }
138 else
139 {
140 //Since "Double Click Editing" is enabled, a command
141 //defined in CUI/CUIX will be fired. Let the code return
142 //and wait the DocumentLockModeChanged and
143 //DocumentLockModeChangeVetoed event handlers do their job
144 return;
145 }
146 }
147 else
148 {
149 ed.WriteMessage(
150 "\nNo custom command is defined agaist the selected entity.");
151 }
152 }
153 }
154 else
155 {
156 ed.WriteMessage("\nNo entity or more than 1 entities selected.");
157 }
158 }
159
160 private static void DocumentManager_DocumentLockModeChanged(
161 object sender, DocumentLockModeChangedEventArgs e)
162 {
163 _runCustomCommand = false;
164 Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
165
166 if (e.GlobalCommandName.Length > 0)
167 {
168 if (_selectedEntId != ObjectId.Null &&
169 !string.IsNullOrEmpty(_customCmd) &&
170 e.GlobalCommandName.ToUpper() != _customCmd.ToUpper())
171 {
172 ed.WriteMessage(
173 "\nCommand {0} is vetoed!", e.GlobalCommandName);
174
175 e.Veto();
176 _runCustomCommand = true;
177 }
178 }
179 }
180
181 private static void DocumentManager_DocumentLockModeChangeVetoed(
182 object sender, DocumentLockModeChangeVetoedEventArgs e)
183 {
184 Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
185
186 if (_runCustomCommand)
187 {
188 ed.WriteMessage(
189 "\nNow running custom command {0} against entity {1}",
190 _customCmd, _selectedEntId.ToString());
191
192 //Start custom command
193 LaunchCustomCommand(ed);
194 }
195 }
196
197 private static void LaunchCustomCommand(Editor ed)
198 {
199 //Create implied a selection set
200 ed.SetImpliedSelection(new ObjectId[] { _selectedEntId });
201
202 string cmd = _customCmd;
203
204 _customCmd = null;
205 _selectedEntId = ObjectId.Null;
206
207 //Start the custom command which has UsePickSet flag set
208 Application.DocumentManager.MdiActiveDocument.SendStringToExecute(
209 cmd + " ", true, false, true);
210 }
211
212 #endregion
213 }
214 }
This video clip shows the code in action.
If reading the code carefully, one should realize that when "DBLCLKEDIT" is enabled, the custom command only launched when the default double-click command defined in CUI/CUIX is vetoed. That means if there is no default double-click command defined in CUI/CUIX defined for particular entity type, then the DocumentLockModeVetoed event will not fire, hence the custom command will not be launched.
6 comments:
thank you for your code sample.
for others who are cutting and pasting the above code, you may find this little utility of benefit: http://remove-line-numbers.ruurtjan.com/
It automatically removes the line number from the code you cut from - it will save you considerable effort!
Hi Norman
thank you for your code.
I'm having a little trouble understanding the logic.
Every command apart from the custom command is vetoed in the DocumentManager_DocumentLockModeChanged handler.
But in the DocumentManager_DocumentLockModeChangeVetoed handler (i.e. the changeVetoed hander), everything is basically run. (provided the _runCustomCommand bool is set - but it will be set on every command that is not the custom Command). In other words, we will be running LaunchCustomCommand for all commands that are not custom commands.
Some clarifications in the logic would be much appreciated.
Sorry for the late reply. I believe that it is this part of code in the Application_BeginDoubleClick() handler that troubles you to understand:
....
131 if (System.Convert.ToInt32(
132 Application.GetSystemVariable("DBLCLKEDIT")) == 0)
133 {
134 //Since "Double click editing" is not enabled, we'll
135 //go ahead to launch our custom command
136 LaunchCustomCommand(ed);
137 }
138 else
139 {
140 //Since "Double Click Editing" is enabled, a command
141 //defined in CUI/CUIX will be fired. Let the code return
142 //and wait the DocumentLockModeChanged and
143 //DocumentLockModeChangeVetoed event handlers do their job
144 return;
145 }
....
That is, why do I call LaunchCutomCommand() in the "If..." and do nothing in "else..."?
When a double_click happens, if "DBLCLCKEDIT" is enabled, a CUI defined command would always run, regardless Application_BeginDoubleClick is handled or not. Only when the double-click event is handled, I get chance to send a custom command, if "DBLCLKEDIT" is not enabled. So, the net effect is when double click occurs, either a custom command, or a CUI defined command starts, which in turn trigger DocumentLockModeChanged event. In its handler, the code checks the command: if it is the custom command with custom command flag set, the the command is allowed to go ahead; if the command is not the custom command and the custom command flag is set, then I veto the command, and in the followed DoculentLockModeChangeVetoed handler, lauch the custom command.
So, the logic is: if "DBLCLKEDIT" is not enabled, custom command will be started in BeginDoubleClick handler. If "DBLCLKEDIT" is enabled, do nothing more then flag custom command and target entity ID in BeginDoubleClick event (because CUI defined command will start); instead use DocumentModeChanged handler to check if custom command is flagged. If yes, veto whatever the command other than custom command. If vetoing occurs, launch he custom command after vetoing. Naturally, the DocumentLockModeChanged event will be handled again. only this time the custom command will not be vetoed and goes ahead.
Hope this explanation goes along with my code.
Regards,
Thank you Norman for your clear explanation.
One problem im finding is that the custom command is launched many times: sometimes it is launched one. but other times it is launched three times - than i get x3 pop up windows which is difficult for the user experience.
any ideas much appreciated.
rgds
i fixed it! the problem was because of my code not the above. chrs.
your code crashes the Autocad when I create a new drawing
Post a Comment