Kean专题(9)—Object_Properties

雪山飞狐_lzh

二、更改动态块属性
March 06, 2009
Painting properties between dynamic AutoCAD blocks using .NET
In the last post we looked at some code that essentially dumped out the dynamic properties of dynamic blocks to the command-line. In this post we take it a step further and capture the properties from one dynamic block reference and attempt to apply them to another.
We're going to apply slightly different logic, depending on the situation...
If the block references refer to the same dynamic block definition (i.e. their DynamicBlockTableRecord property contains the same ObjectId) then we'll assume they have the same dynamic properties in the same order. So we'll go through and attempt to copy the property value from the first to the second. This may be a flawed approach, I don't know enough to say whether there are situations where dynamic blocks might have different sets of properties or properties in a different order... if it proves to be a problem, it'd be a simple matter to remove this clause and rely on the second approach for all dynamic block references.
If the block references refer to different dynamic block definitions (i.e. their DynamicBlockTableRecord property contains different ObjectIds) then we use a slightly more elaborate approach: we go through the dynamic properties of the "source" dynamic block reference and store them in a dictionary. We then go through the dynamic properties of the "target" dynamic block reference, and if we find a value in the list we then attempt to apply it to this reference. In this way we should be able to paint properties across blocks - as long as they have the same name - even if they don't have the same overall make-up.
Here's the C# code:

2. using Autodesk.AutoCAD.ApplicationServices;
3. using Autodesk.AutoCAD.DatabaseServices;
4. using Autodesk.AutoCAD.EditorInput;
5. using Autodesk.AutoCAD.Geometry;
6. using Autodesk.AutoCAD.Runtime;
7. using System.Collections.Generic;
9. namespace DynamicBlocks2
10. {
11.   public class Commands
12.   {
13.     [CommandMethod("ADBP")]
14.     static public void ApplyDynamicBlockProps()
15.     {
16.       Document doc =
17.         Application.DocumentManager.MdiActiveDocument;
18.       Database db = doc.Database;
19.       Editor ed = doc.Editor;
21.       // Select the source and target block references
23.       PromptEntityOptions peo =
24.         new PromptEntityOptions(
25.           "\nSelect source dynamic block reference: "
26.         );
28.       peo.SetRejectMessage("\nEntity is not a block.");
29.       peo.AddAllowedClass(typeof(BlockReference), false);
31.       PromptEntityResult per =
32.         ed.GetEntity(peo);
34.       if (per.Status != PromptStatus.OK)
35.         return;
37.       ObjectId sourceId = per.ObjectId;
39.       peo.Message =
40.         "\nSelect target dynamic block reference: ";
41.       per = ed.GetEntity(peo);
43.       if (per.Status != PromptStatus.OK)
44.         return;
46.       ObjectId targetId = per.ObjectId;
48.       Transaction tr =
49.         db.TransactionManager.StartTransaction();
50.       using (tr)
51.       {
52.         // Open our block references: the source (br1)
53.         // for read and the target (br2) for write
55.         BlockReference br1 =
56.           (BlockReference)tr.GetObject(
57.             sourceId,
58.             OpenMode.ForRead
59.           );
61.         BlockReference br2 =
62.           (BlockReference)tr.GetObject(
63.             targetId,
64.             OpenMode.ForWrite
65.           );
67.         // They must both be dynamic block references
69.         if (br1 != null && br1.IsDynamicBlock &&
70.             br2 != null && br2.IsDynamicBlock)
71.         {
72.           if (br1.DynamicBlockTableRecord ==
73.               br2.DynamicBlockTableRecord)
74.           {
75.             // They use the same block definition - let's assume
76.             // the properties are in the same order
78.             DynamicBlockReferencePropertyCollection pc1 =
79.               br1.DynamicBlockReferencePropertyCollection;
81.             DynamicBlockReferencePropertyCollection pc2 =
82.               br2.DynamicBlockReferencePropertyCollection;
84.             if (pc1.Count == pc2.Count)
85.             {
86.               for (int i = 0; i < pc1.Count; i++)
87.               {
88.                 // Get each property. If they have the same
89.                 // name and are not read-only, attempt to
90.                 // copy the value from the source (prop1)
91.                 // to the target (prop2)
93.                 DynamicBlockReferenceProperty prop1 = pc1[i],
94.                                               prop2 = pc2[i];
95.                 if (prop1.PropertyName == prop2.PropertyName &&
96.                     !prop1.ReadOnly && !prop2.ReadOnly)
97.                 {
98.                   prop2.Value = prop1.Value;
99.                 }
100.               }
101.             }
102.           }
103.           else
104.           {
105.             // If the block references refer to different
106.             // dynamic block definitions, let's collect the
107.             // properties for the first in a dictionary and
108.             // attempt to apply them to the second
110.             DynamicBlockReferencePropertyCollection pc1 =
111.               br1.DynamicBlockReferencePropertyCollection;
113.             // Create and populate our dictionary
115.             Dictionary<string, DynamicBlockReferenceProperty> dict =
116.               new
117.               Dictionary<string, DynamicBlockReferenceProperty>();
119.             foreach (DynamicBlockReferenceProperty prop in pc1)
120.             {
121.               if (!prop.ReadOnly &&
122.                   !dict.ContainsKey(prop.PropertyName))
123.                 dict.Add(prop.PropertyName, prop);
124.             }
126.             // Try to copy them to the target block reference's
127.             // dynamic properties
129.             DynamicBlockReferencePropertyCollection pc2 =
130.               br2.DynamicBlockReferencePropertyCollection;
132.             foreach (DynamicBlockReferenceProperty prop2 in pc2)
133.             {
134.               if (!prop2.ReadOnly &&
135.                   dict.ContainsKey(prop2.PropertyName))
136.               {
137.                 try
138.                 {
139.                   DynamicBlockReferenceProperty prop1;
140.                   if (dict.TryGetValue(
141.                         prop2.PropertyName, out prop1
142.                     )
143.                   )
144.                   {
145.                     if (prop2.PropertyTypeCode ==
146.                         prop1.PropertyTypeCode)
147.                     {
148.                       prop2.Value = prop1.Value;
149.                     }
150.                   }
151.                 }
152.                 // Expand if you want to diagnose specific issues
153.                 catch { }
154.               }
155.             }
156.           }
157.         }
158.         else
159.         {
160.           ed.WriteMessage(
161.             "\nYou need to select two dynamic bock references."
162.           );
163.         }
164.         tr.Commit();
165.       }
166.     }
167.   }
168. }

using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.Geometry; using Autodesk.AutoCAD.Runtime; using System.Collections.Generic; namespace DynamicBlocks2 {   public class Commands   {     [CommandMethod("ADBP")]     static public void ApplyDynamicBlockProps()     {       Document doc =         Application.DocumentManager.MdiActiveDocument;       Database db = doc.Database;       Editor ed = doc.Editor;       // Select the source and target block references       PromptEntityOptions peo =         new PromptEntityOptions(           "\nSelect source dynamic block reference: "         );       peo.SetRejectMessage("\nEntity is not a block.");       peo.AddAllowedClass(typeof(BlockReference), false);       PromptEntityResult per =         ed.GetEntity(peo);       if (per.Status != PromptStatus.OK)         return;       ObjectId sourceId = per.ObjectId;       peo.Message =         "\nSelect target dynamic block reference: ";       per = ed.GetEntity(peo);       if (per.Status != PromptStatus.OK)         return;       ObjectId targetId = per.ObjectId;       Transaction tr =         db.TransactionManager.StartTransaction();       using (tr)       {         // Open our block references: the source (br1)         // for read and the target (br2) for write         BlockReference br1 =           (BlockReference)tr.GetObject(             sourceId,             OpenMode.ForRead           );         BlockReference br2 =           (BlockReference)tr.GetObject(             targetId,             OpenMode.ForWrite           );         // They must both be dynamic block references         if (br1 != null && br1.IsDynamicBlock &&             br2 != null && br2.IsDynamicBlock)         {           if (br1.DynamicBlockTableRecord ==               br2.DynamicBlockTableRecord)           {             // They use the same block definition - let's assume             // the properties are in the same order             DynamicBlockReferencePropertyCollection pc1 =               br1.DynamicBlockReferencePropertyCollection;             DynamicBlockReferencePropertyCollection pc2 =               br2.DynamicBlockReferencePropertyCollection;             if (pc1.Count == pc2.Count)             {               for (int i = 0; i < pc1.Count; i++)               {                 // Get each property. If they have the same                 // name and are not read-only, attempt to                 // copy the value from the source (prop1)                 // to the target (prop2)                 DynamicBlockReferenceProperty prop1 = pc1[i],                                               prop2 = pc2[i];                 if (prop1.PropertyName == prop2.PropertyName &&                     !prop1.ReadOnly && !prop2.ReadOnly)                 {                   prop2.Value = prop1.Value;                 }               }             }           }           else           {             // If the block references refer to different             // dynamic block definitions, let's collect the             // properties for the first in a dictionary and             // attempt to apply them to the second             DynamicBlockReferencePropertyCollection pc1 =               br1.DynamicBlockReferencePropertyCollection;             // Create and populate our dictionary             Dictionary<string, DynamicBlockReferenceProperty> dict =               new               Dictionary<string, DynamicBlockReferenceProperty>();             foreach (DynamicBlockReferenceProperty prop in pc1)             {               if (!prop.ReadOnly &&                   !dict.ContainsKey(prop.PropertyName))                 dict.Add(prop.PropertyName, prop);             }             // Try to copy them to the target block reference's             // dynamic properties             DynamicBlockReferencePropertyCollection pc2 =               br2.DynamicBlockReferencePropertyCollection;             foreach (DynamicBlockReferenceProperty prop2 in pc2)             {               if (!prop2.ReadOnly &&                   dict.ContainsKey(prop2.PropertyName))               {                 try                 {                   DynamicBlockReferenceProperty prop1;                   if (dict.TryGetValue(                         prop2.PropertyName, out prop1                     )                   )                   {                     if (prop2.PropertyTypeCode ==                         prop1.PropertyTypeCode)                     {                       prop2.Value = prop1.Value;                     }                   }                 }                 // Expand if you want to diagnose specific issues                 catch { }               }             }           }         }         else         {           ed.WriteMessage(             "\nYou need to select two dynamic bock references."           );         }         tr.Commit();       }     }   } }

Let's see what happens when we put our ADBP command through its paces. Here's our initial state - we have two differently-sized instances of the same dynamic block, plus one instance of a different dynamic block (which shares parameters - the left-hand block is a "Hex Socket Bolt (Side)" while the right-hand block is a "Hex Nut" - both these blocks are available in the "Mechanical - Metric.dwg" sample file in the Samples\Dynamic Blocks folder of your AutoCAD installation).

Dynamic block references
Here's where we are when we run our ADBP command and select the block reference at the top followed by the block reference at the bottom-left:

Dynamic block references - after paint from top to bottom elevation view
So we see it works on references of the same dynamic block definition. Now let's try it, selecting one of the left-hand elevation views on the bolt, followed by the plan view of the nut on the right:

Dynamic block references - after paint from elevation to plan view
Because they share a dynamic property ("Size", which went from "M10" to "M14"), we were able to "paint" from one to the other.
With AutoCAD 2010 you'll be able to create constraints between geometry - which is a much simpler and more powerful approach - but what we've seen in this post should be of use to people working with dynamic blocks today.
By the way - for those of you with ADN website access - I used this DevNote as inspiration for how to modify properties in a dynamic block reference: How to programmatically insert a dynamic block with attributes containing dynamic parameters? (requires login.) Thanks to Fernando for pointing me to it (at that point in my research I had not quite gotten as far as checking the ADN website... ahem), as well as for suggesting this topic in the first place.

雪山飞狐_lzh

uly 15, 2009
Adding a dynamic distance property to an AutoCAD object using .NET
Back in these previous posts, we introduced an ObjectARX module that exposed AutoCAD’s Property Palette to .NET (thanks again to Cyrille Fauvel for his work on this :-). In this post we’re going to build on this work to demonstrate how to integrate properties with more advanced editing controls into the Property Palette.
[Note: this sample does not deal with persisting the data with an object. If you want to store your data with a particular object, I suggest taking a look at this previous post which demonstrates how to use Xdata to do so.]
This code is being built on top of the sample project provided with the OPM .NET implementation, which I’ve posted previously for AutoCAD 2007-2009 and for AutoCAD 2010. It defines a custom dynamic property – much like the original CustomProp, an integer property – but this one implements a new interface, IAcPiPropertyDisplay. This special interface allows you to – among other things – specify a custom editing control, which gets instantiated by the Property Palette and is then used to allow editing of the property.
The ObjectARX documentation contains this information on the main method we’re interested in implementing, GetCustomPropertyCtrl():
    Supplies a custom ActiveX control for property display/edit on a per-property basis.
    Before attempting to pick one of the ACPEX stock custom ActiveX controls for property display/edit, the Property Inspector calls this method to see if the object/command wishes to supply its own custom ActiveX control. This method is called on a per-property basis (both static and dynamic) for an object/command whose properties are active for display in the Property Inspector.
    The supplied custom control must implement IPropertyEditCtrl to be displayed for property value display/edit. The Property Inspector releases the output BSTR pointer after its use.
We want to enable this interface for use from .NET. In the previous cases we’ve had to do some extra work to expose or enable our Property Palette interfaces for use from .NET, but luckily this work has already been done for AutoCAD’s Tool Palette implementation. We can now simply add an assembly reference to AcTcMgd.dll and include the Autodesk.AutoCAD.Windows.ToolPalette namespace in our code.
[Note: I found this assembly in the inc-win32 folder of the ObjectARX SDK for AutoCAD 2010 (I’m running AutoCAD 2010 on Vista 32-bit), and it’s not clear to me when exactly we delivered this implementation - whether it was done for AutoCAD 2010 or beforehand. If AcTcMgd.dll is not available for your version of AutoCAD, it is still an option to expose this interface for use from .NET yourself, following the examples shown when we originally introduced the OPM .NET implementation.]
When we implement our GetCustomPropertyCtrl() method, we then need to set the string output argument to the ProgId of the editing control we wish to use. To decide an appropriate ProgId, I looked into the Registry, to identify the candidates:

Various AcPEXCtl ProgIds in the Registry
It’s also possible to implement your own truly custom editing control exposing the IPropertyEditCtrl interface, but that’s way beyond the scope of this post. :-)
For our custom distance property, we’re going to use a (standard) custom control that allows the user to select two points in the drawing; the distance between them then gets set as our dynamic property’s value. The ProgId for this control is “AcPEXCtl.AcPePick2PointsCtrl.16”.
Otherwise the methods of IAcPiPropertyDisplay should be fairly straightforward to understand, although perhaps IsFullView() requires a little explanation: the “visible” parameter actually indicates whether the control should take up the whole of the row – obscuring the property name – which is why we set it to false.
One final note: I’ve remapped the GUID for the property, to prevent it from conflicting with the previous CustomProp implementation.
Here’s the C# code for our custom distance property:

2. using Autodesk.AutoCAD.Runtime;
3. using Autodesk.AutoCAD.Windows.OPM;
4. using Autodesk.AutoCAD.Windows.ToolPalette;
5. using System;
6. using System.Reflection;
7. using System.Runtime.InteropServices;
9. namespace OPMNetSample
10. {
11.   #region Our Custom Distance Property
12.   [
13.     Guid("78286EBD-7380-4bb5-9EA6-1742677FA2E3"),
14.     ProgId("OPMNetSample.DistanceProperty.1"),
15.     ClassInterface(ClassInterfaceType.None),
16.     ComDefaultInterface(typeof(IDynamicProperty2)),
17.     ComVisible(true)
18.   ]
19.   public class DistanceProp : IDynamicProperty2, IAcPiPropertyDisplay
20.   {
21.     private IDynamicPropertyNotify2 _pSink = null;
22.     private double _value = 0.0;
24.     #region IDynamicProperty2 methods
26.     // Unique property ID
28.     public void GetGUID(out Guid propGUID)
29.     {
30.       propGUID =
31.         new Guid("78286EBD-7380-4bb5-9EA6-1742677FA2E3");
32.     }
34.     // Property display name
36.     public void GetDisplayName(out string szName)
37.     {
38.       szName = "Distance";
39.     }
41.     // Show/Hide property in the OPM, for this object instance
43.     public void IsPropertyEnabled(object pUnk, out int bEnabled)
44.     {
45.       bEnabled = 1;
46.     }
48.     // Is property showing but disabled
50.     public void IsPropertyReadOnly(out int bReadonly)
51.     {
52.       bReadonly = 0;
53.     }
55.     // Get the property description string
57.     public void GetDescription(out string szName)
58.     {
59.       szName =
60.         "This distance property is from picking two points";
61.     }
63.     // OPM will typically display these in an edit field
64.     // optional: meta data representing property type name,
65.     // ex. ACAD_ANGLE
67.     public void GetCurrentValueName(out string szName)
68.     {
69.       throw new System.NotImplementedException();
70.     }
72.     // What is the property type, ex. VT_R8
74.     public void GetCurrentValueType(out ushort varType)
75.     {
76.       // The Property Inspector supports the following data
77.       // types for dynamic properties:
78.       // VT_I2 (2), VT_I4 (3), VT_R4 (4), VT_R8 (5),
79.       // VT_BSTR (8), VT_BOOL (11), and VT_USERDEFINED (29).
81.       varType = 4; // VT_R4
82.     }
84.     // Get the property value, passes the specific object
85.     // we need the property value for.
87.     public void GetCurrentValueData(object pUnk, ref object pVarData)
88.     {
89.       pVarData = _value;
90.     }
92.     // Set the property value, passes the specific object we
93.     // want to set the property value for
95.     public void SetCurrentValueData(object pUnk, object varData)
96.     {
97.       _value = (double)varData;
98.     }
100.     // OPM passes its implementation of IDynamicPropertyNotify, you
101.     // cache it and call it to inform OPM your property has changed
103.     public void Connect(object pSink)
104.     {
105.       _pSink = (IDynamicPropertyNotify2)pSink;
106.     }
108.     public void Disconnect() {
109.       _pSink = null;
110.     }
112.     #endregion
114.     #region IAcPiPropertyDisplay methods
116.     public void GetCustomPropertyCtrl(
117.       object id, uint lcid, out string progId
118.     )
119.     {
120.       progId = "AcPEXCtl.AcPePick2PointsCtrl.16";
121.     }
123.     public void GetPropertyWeight(object id, out int propertyWeight)
124.     {
125.       propertyWeight = 0;
126.     }
128.     public void GetPropertyIcon(object id, out object icon)
129.     {
130.       icon = null;
131.     }
133.     public void GetPropTextColor(object id, out uint textColor)
134.     {
135.       textColor = 0;
136.     }
138.     public void IsFullView(
139.       object id, out bool visible, out uint integralHeight
140.     )
141.     {
142.       visible = false;
143.       integralHeight = 1;
144.     }
145.     #endregion
146.   }
147.   #endregion
149.   #region Application Entry Point
150.   public class MyEntryPoint : IExtensionApplication
151.   {
152.     protected internal DistanceProp distProp = null;
154.     public void Initialize()
155.     {
156.       Assembly.LoadFrom("asdkOPMNetExt.dll");
158.       // Add the Dynamic Property
160.       Dictionary classDict = SystemObjects.ClassDictionary;
161.       RXClass lineDesc = (RXClass)classDict.At("AcDbLine");
162.       IPropertyManager2 pPropMan =
163.         (IPropertyManager2)xOPM.xGET_OPMPROPERTY_MANAGER(lineDesc);
165.       distProp = new DistanceProp();
166.       pPropMan.AddProperty((object)distProp);
167.     }
169.     public void Terminate()
170.     {
171.       // Remove the Dynamic Property
173.       Dictionary classDict = SystemObjects.ClassDictionary;
174.       RXClass lineDesc = (RXClass)classDict.At("AcDbLine");
175.       IPropertyManager2 pPropMan =
176.         (IPropertyManager2)xOPM.xGET_OPMPROPERTY_MANAGER(lineDesc);
178.       pPropMan.RemoveProperty((object)distProp);
179.       distProp = null;
180.     }
181.   }
182.   #endregion
183. }

using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.Windows.OPM; using Autodesk.AutoCAD.Windows.ToolPalette; using System; using System.Reflection; using System.Runtime.InteropServices; namespace OPMNetSample {   #region Our Custom Distance Property   [     Guid("78286EBD-7380-4bb5-9EA6-1742677FA2E3"),     ProgId("OPMNetSample.DistanceProperty.1"),     ClassInterface(ClassInterfaceType.None),     ComDefaultInterface(typeof(IDynamicProperty2)),     ComVisible(true)   ]   public class DistanceProp : IDynamicProperty2, IAcPiPropertyDisplay   {     private IDynamicPropertyNotify2 _pSink = null;     private double _value = 0.0;     #region IDynamicProperty2 methods     // Unique property ID     public void GetGUID(out Guid propGUID)     {       propGUID =         new Guid("78286EBD-7380-4bb5-9EA6-1742677FA2E3");     }     // Property display name     public void GetDisplayName(out string szName)     {       szName = "Distance";     }     // Show/Hide property in the OPM, for this object instance     public void IsPropertyEnabled(object pUnk, out int bEnabled)     {       bEnabled = 1;     }     // Is property showing but disabled     public void IsPropertyReadOnly(out int bReadonly)     {       bReadonly = 0;     }     // Get the property description string     public void GetDescription(out string szName)     {       szName =         "This distance property is from picking two points";     }     // OPM will typically display these in an edit field     // optional: meta data representing property type name,     // ex. ACAD_ANGLE     public void GetCurrentValueName(out string szName)     {       throw new System.NotImplementedException();     }     // What is the property type, ex. VT_R8     public void GetCurrentValueType(out ushort varType)     {       // The Property Inspector supports the following data       // types for dynamic properties:       // VT_I2 (2), VT_I4 (3), VT_R4 (4), VT_R8 (5),       // VT_BSTR (8), VT_BOOL (11), and VT_USERDEFINED (29).       varType = 4; // VT_R4     }     // Get the property value, passes the specific object     // we need the property value for.     public void GetCurrentValueData(object pUnk, ref object pVarData)     {       pVarData = _value;     }     // Set the property value, passes the specific object we     // want to set the property value for     public void SetCurrentValueData(object pUnk, object varData)     {       _value = (double)varData;     }     // OPM passes its implementation of IDynamicPropertyNotify, you     // cache it and call it to inform OPM your property has changed     public void Connect(object pSink)     {       _pSink = (IDynamicPropertyNotify2)pSink;     }     public void Disconnect() {       _pSink = null;     }     #endregion     #region IAcPiPropertyDisplay methods     public void GetCustomPropertyCtrl(       object id, uint lcid, out string progId     )     {       progId = "AcPEXCtl.AcPePick2PointsCtrl.16";     }     public void GetPropertyWeight(object id, out int propertyWeight)     {       propertyWeight = 0;     }     public void GetPropertyIcon(object id, out object icon)     {       icon = null;     }     public void GetPropTextColor(object id, out uint textColor)     {       textColor = 0;     }     public void IsFullView(       object id, out bool visible, out uint integralHeight     )     {       visible = false;       integralHeight = 1;     }     #endregion   }   #endregion   #region Application Entry Point   public class MyEntryPoint : IExtensionApplication   {     protected internal DistanceProp distProp = null;     public void Initialize()     {       Assembly.LoadFrom("asdkOPMNetExt.dll");       // Add the Dynamic Property       Dictionary classDict = SystemObjects.ClassDictionary;       RXClass lineDesc = (RXClass)classDict.At("AcDbLine");       IPropertyManager2 pPropMan =         (IPropertyManager2)xOPM.xGET_OPMPROPERTY_MANAGER(lineDesc);       distProp = new DistanceProp();       pPropMan.AddProperty((object)distProp);     }     public void Terminate()     {       // Remove the Dynamic Property       Dictionary classDict = SystemObjects.ClassDictionary;       RXClass lineDesc = (RXClass)classDict.At("AcDbLine");       IPropertyManager2 pPropMan =         (IPropertyManager2)xOPM.xGET_OPMPROPERTY_MANAGER(lineDesc);       pPropMan.RemoveProperty((object)distProp);       distProp = null;     }   }   #endregion }

Here’s what we see when we NETLOAD the asdkOPMNetExt.dll and our OPMNetSample.dll, and then select a standard line:

Our new dynamic distance property on the line object
When we select the property we see we get a custom editing icon:

Our new dynamic distance property with its pick two points function
When we click that button, we get prompted to select two points in the drawing:
Pick a start point in the drawing:
Pick an end point in the drawing:
Once we’ve done so, the distance between the two points gets assigned to our property:

Bear in mind that we’re currently storing this value with the property, not with the line itself. So you’ll see the same value irrespective of the line you’ve selected. See the note at the beginning of this post if you wish to go further and attach this data per object.
I’m going to spend some time looking further into the capabilities of the custom control mechanism: in the next post in this series we’ll look at hosting a masked string (as in a password) dynamic property inside the Property Palette. If you have suggestions for additional controls to implement, please let me know (and I’ll see what I can figure out :-).

雪山飞狐_lzh

July 20, 2009
Adding a dynamic password property to an AutoCAD object using .NET
In this recent post we looked at adding custom editing capabilities for dynamic properties we’ve added via .NET. In the first example we looked at a “distance” property which provided a button allowing the user to select two points. In this post we’ll look at implementing a masked string property, such as one you would use for a password.
I won’t repeat too much of the background information from the last post in this series: you should refer to that to understand the fundamentals (the fact that we’re basing this implementation on Cyrille Fauvel’s OPM .NET sample, that we’re not dealing with per-object persistence, and that we’re using “stock” ActiveX editing controls we’ve discovered via the Registry). That said, the code we’re providing here stands alone from the code in the last post, even if it’s altogether possible to combine them.
Here is the C# code to implement a simple, masked string dynamic property:

2. using Autodesk.AutoCAD.Runtime;
3. using Autodesk.AutoCAD.Windows.OPM;
4. using Autodesk.AutoCAD.Windows.ToolPalette;
5. using System;
6. using System.Reflection;
7. using System.Runtime.InteropServices;
9. namespace OPMNetSample
10. {
11.   #region Our Custom Password Property
12.   [
13.     Guid("B5D9010E-48A2-4bfb-8601-76A7B1007C68"),
14.     ProgId("OPMNetSample.PasswordProperty.1"),
15.     ClassInterface(ClassInterfaceType.None),
16.     ComDefaultInterface(typeof(IDynamicProperty2)),
17.     ComVisible(true)
18.   ]
19.   public class PasswordProp : IDynamicProperty2, IAcPiPropertyDisplay
20.   {
21.     private IDynamicPropertyNotify2 _pSink = null;
22.     private string _password = "";
24.     #region IDynamicProperty2 methods
26.     // Unique property ID
28.     public void GetGUID(out Guid propGUID)
29.     {
30.       propGUID =
31.         new Guid("B5D9010E-48A2-4bfb-8601-76A7B1007C68");
32.     }
34.     // Property display name
36.     public void GetDisplayName(out string szName)
37.     {
38.       szName = "Password";
39.     }
41.     // Show/Hide property in the OPM, for this object instance
43.     public void IsPropertyEnabled(object pUnk, out int bEnabled)
44.     {
45.       bEnabled = 1;
46.     }
48.     // Is property showing but disabled
50.     public void IsPropertyReadOnly(out int bReadonly)
51.     {
52.       bReadonly = 0;
53.     }
55.     // Get the property description string
57.     public void GetDescription(out string szName)
58.     {
59.       szName =
60.         "This masked property is a string";
61.     }
63.     // OPM will typically display these in an edit field
64.     // optional: meta data representing property type name,
65.     // ex. ACAD_ANGLE
67.     public void GetCurrentValueName(out string szName)
68.     {
69.       throw new System.NotImplementedException();
70.     }
72.     // What is the property type, ex. VT_R8
74.     public void GetCurrentValueType(out ushort varType)
75.     {
76.       // The Property Inspector supports the following data
77.       // types for dynamic properties:
78.       // VT_I2 (2), VT_I4 (3), VT_R4 (4), VT_R8 (5),
79.       // VT_BSTR (8), VT_BOOL (11), and VT_USERDEFINED (29).
81.       varType = 8; // VT_BSTR
82.     }
84.     // Get the property value, passes the specific object
85.     // we need the property value for.
87.     public void GetCurrentValueData(object pUnk, ref object pVarData)
88.     {
89.       pVarData = _password;
90.     }
92.     // Set the property value, passes the specific object we
93.     // want to set the property value for
95.     public void SetCurrentValueData(object pUnk, object varData)
96.     {
97.       _password = varData.ToString();
98.       System.Windows.Forms.MessageBox.Show(
99.         "String entered was "" + _password + ""."
100.       );
101.     }
103.     // OPM passes its implementation of IDynamicPropertyNotify, you
104.     // cache it and call it to inform OPM your property has changed
106.     public void Connect(object pSink)
107.     {
108.       _pSink = (IDynamicPropertyNotify2)pSink;
109.     }
111.     public void Disconnect() {
112.       _pSink = null;
113.     }
115.     #endregion
117.     #region IAcPiPropertyDisplay methods
119.     public void GetCustomPropertyCtrl(
120.       object id, uint lcid, out string progId
121.     )
122.     {
123.       progId = "AcPEXCtl.AcPePropertyEditorPwdText.16";
124.     }
126.     public void GetPropertyWeight(object id, out int propertyWeight)
127.     {
128.       propertyWeight = 0;
129.     }
131.     public void GetPropertyIcon(object id, out object icon)
132.     {
133.       icon = null;
134.     }
136.     public void GetPropTextColor(object id, out uint textColor)
137.     {
138.       textColor = 0;
139.     }
141.     public void IsFullView(
142.       object id, out bool visible, out uint integralHeight
143.     )
144.     {
145.       visible = false;
146.       integralHeight = 1;
147.     }
148.     #endregion
149.   }
150.   #endregion
152.   #region Application Entry Point
153.   public class MyEntryPoint : IExtensionApplication
154.   {
155.     protected internal PasswordProp passProp = null;
157.     public void Initialize()
158.     {
159.       Assembly.LoadFrom("asdkOPMNetExt.dll");
161.       // Add the Dynamic Property
163.       Dictionary classDict = SystemObjects.ClassDictionary;
164.       RXClass lineDesc = (RXClass)classDict.At("AcDbLine");
165.       IPropertyManager2 pPropMan =
166.         (IPropertyManager2)xOPM.xGET_OPMPROPERTY_MANAGER(lineDesc);
168.       passProp = new PasswordProp();
169.       pPropMan.AddProperty((object)passProp);
170.     }
172.     public void Terminate()
173.     {
174.       // Remove the Dynamic Property
176.       Dictionary classDict = SystemObjects.ClassDictionary;
177.       RXClass lineDesc = (RXClass)classDict.At("AcDbLine");
178.       IPropertyManager2 pPropMan =
179.         (IPropertyManager2)xOPM.xGET_OPMPROPERTY_MANAGER(lineDesc);
181.       pPropMan.RemoveProperty((object)passProp);
182.       passProp = null;
183.     }
184.   }
185.   #endregion
186. }

using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.Windows.OPM; using Autodesk.AutoCAD.Windows.ToolPalette; using System; using System.Reflection; using System.Runtime.InteropServices; namespace OPMNetSample {   #region Our Custom Password Property   [     Guid("B5D9010E-48A2-4bfb-8601-76A7B1007C68"),     ProgId("OPMNetSample.PasswordProperty.1"),     ClassInterface(ClassInterfaceType.None),     ComDefaultInterface(typeof(IDynamicProperty2)),     ComVisible(true)   ]   public class PasswordProp : IDynamicProperty2, IAcPiPropertyDisplay   {     private IDynamicPropertyNotify2 _pSink = null;     private string _password = "";     #region IDynamicProperty2 methods     // Unique property ID     public void GetGUID(out Guid propGUID)     {       propGUID =         new Guid("B5D9010E-48A2-4bfb-8601-76A7B1007C68");     }     // Property display name     public void GetDisplayName(out string szName)     {       szName = "Password";     }     // Show/Hide property in the OPM, for this object instance     public void IsPropertyEnabled(object pUnk, out int bEnabled)     {       bEnabled = 1;     }     // Is property showing but disabled     public void IsPropertyReadOnly(out int bReadonly)     {       bReadonly = 0;     }     // Get the property description string     public void GetDescription(out string szName)     {       szName =         "This masked property is a string";     }     // OPM will typically display these in an edit field     // optional: meta data representing property type name,     // ex. ACAD_ANGLE     public void GetCurrentValueName(out string szName)     {       throw new System.NotImplementedException();     }     // What is the property type, ex. VT_R8     public void GetCurrentValueType(out ushort varType)     {       // The Property Inspector supports the following data       // types for dynamic properties:       // VT_I2 (2), VT_I4 (3), VT_R4 (4), VT_R8 (5),       // VT_BSTR (8), VT_BOOL (11), and VT_USERDEFINED (29).       varType = 8; // VT_BSTR     }     // Get the property value, passes the specific object     // we need the property value for.     public void GetCurrentValueData(object pUnk, ref object pVarData)     {       pVarData = _password;     }     // Set the property value, passes the specific object we     // want to set the property value for     public void SetCurrentValueData(object pUnk, object varData)     {       _password = varData.ToString();       System.Windows.Forms.MessageBox.Show(         "String entered was "" + _password + ""."       );     }     // OPM passes its implementation of IDynamicPropertyNotify, you     // cache it and call it to inform OPM your property has changed     public void Connect(object pSink)     {       _pSink = (IDynamicPropertyNotify2)pSink;     }     public void Disconnect() {       _pSink = null;     }     #endregion     #region IAcPiPropertyDisplay methods     public void GetCustomPropertyCtrl(       object id, uint lcid, out string progId     )     {       progId = "AcPEXCtl.AcPePropertyEditorPwdText.16";     }     public void GetPropertyWeight(object id, out int propertyWeight)     {       propertyWeight = 0;     }     public void GetPropertyIcon(object id, out object icon)     {       icon = null;     }     public void GetPropTextColor(object id, out uint textColor)     {       textColor = 0;     }     public void IsFullView(       object id, out bool visible, out uint integralHeight     )     {       visible = false;       integralHeight = 1;     }     #endregion   }   #endregion   #region Application Entry Point   public class MyEntryPoint : IExtensionApplication   {     protected internal PasswordProp passProp = null;     public void Initialize()     {       Assembly.LoadFrom("asdkOPMNetExt.dll");       // Add the Dynamic Property       Dictionary classDict = SystemObjects.ClassDictionary;       RXClass lineDesc = (RXClass)classDict.At("AcDbLine");       IPropertyManager2 pPropMan =         (IPropertyManager2)xOPM.xGET_OPMPROPERTY_MANAGER(lineDesc);       passProp = new PasswordProp();       pPropMan.AddProperty((object)passProp);     }     public void Terminate()     {       // Remove the Dynamic Property       Dictionary classDict = SystemObjects.ClassDictionary;       RXClass lineDesc = (RXClass)classDict.At("AcDbLine");       IPropertyManager2 pPropMan =         (IPropertyManager2)xOPM.xGET_OPMPROPERTY_MANAGER(lineDesc);       pPropMan.RemoveProperty((object)passProp);       passProp = null;     }   }   #endregion }

Let’s see what happens when we NETLOAD the asdkOPMNetExt.dll and our OPMNetSample.dll, and then select a standard line:

Once we start entering a string inside our dynamic password property, we see it displayed as a masked string:

And once we finish entering our string, we can see that our code has the unmasked data available to it – here’s a MessageBox we throw up to display the contents:

If we really wanted to store this securely – to avoid any determined application from snooping the underlying data – then we would really need to encrypt it before assigning it to our object (whether in Xdata or an Xrecord stored in the extension dictionary of an object). Beyond that we might even want to take measures to make sure the variable – as stored in memory, not just persisted with the object – isn’t readable by external applications. But again, this is beyond the scope of this post, which is really just to introduce another property editing control available inside AutoCAD.

雪山飞狐_lzh

创建尺寸式样替代
September 07, 2009
Creating and overriding AutoCAD dimension styles using .NET
A request came in by email during last week’s vacation:
    I have been looking around to find a way about creating Dimension Style Overrides, but have not really had any success at anything yet. I have created program in which I do create several dimension styles, but I just keep getting lost with the overrides.
This seemed like a really good topic to cover, so this post contains some simple code that to create a dimension style and two nearly-identical linear dimensions: both use our newly-created dimension style but the second of the two also contains some Dimension Style Overrides, which we attach to the dimension via External Entity Data (XData).
Here’s the C# code:

2. using Autodesk.AutoCAD.ApplicationServices;
3. using Autodesk.AutoCAD.DatabaseServices;
4. using Autodesk.AutoCAD.EditorInput;
5. using Autodesk.AutoCAD.Geometry;
6. using Autodesk.AutoCAD.Runtime;
8. namespace DimStyleOverrideTest
9. {
10.   public class Commands
11.   {
12.     [CommandMethod("ODS")]
13.     public void OverrideDimensionStyle()
14.     {
15.       Database db =
16.         HostApplicationServices.WorkingDatabase;
18.       Transaction tr =
19.         db.TransactionManager.StartTransaction();
20.       using (tr)
21.       {
22.         // Open our dimension style table to add our
23.         // new dimension style
25.         DimStyleTable dst =
26.           (DimStyleTable)tr.GetObject(
27.             db.DimStyleTableId, OpenMode.ForWrite
28.           );
30.         // Create our new dimension style
32.         DimStyleTableRecord dstr =
33.           new DimStyleTableRecord();
34.         dstr.Dimtad = 2;
35.         dstr.Dimgap = 0.3;
36.         dstr.Name = "MyStyle";
38.         // Add it to the dimension style table
40.         ObjectId dsId = dst.Add(dstr);
41.         tr.AddNewlyCreatedDBObject(dstr, true);
43.         // Now create two identical dimensions, one
44.         // next to the other, using our dimension
45.         // style
47.         AlignedDimension ad1 =
48.           new AlignedDimension(
49.             Point3d.Origin,
50.             new Point3d(5.0, 0.0, 0.0),
51.             new Point3d(2.5, 2.0, 0.0),
52.             "Standard dimension",
53.             dsId
54.           );
56.         // The only thing we change is the text string
58.         AlignedDimension ad2 =
59.           new AlignedDimension(
60.             new Point3d(5.0, 0.0, 0.0),
61.             new Point3d(10.0, 0.0, 0.0),
62.             new Point3d(7.5, 2.0, 0.0),
63.             "Overridden dimension",
64.             dsId
65.           );
67.         /*
69.         Now we'll add dimension overrides for DIMTAD
70.         and DIMGAP via XData
72.         Dimension variable group codes are:
74.           DIMPOST     3
75.           DIMAPOST    4
76.           DIMSCALE   40
77.           DIMASZ     41
78.           DIMEXO     42
79.           DIMDLI     43
80.           DIMEXE     44
81.           DIMRND     45
82.           DIMDLE     46
83.           DIMTP      47
84.           DIMTM      48
85.           DIMTOL     71
86.           DIMLIM     72
87.           DIMTIH     73
88.           DIMTOH     74
89.           DIMSE1     75
90.           DIMSE2     76
91.           DIMTAD     77
92.           DIMZIN     78
93.           DIMAZIN    79
94.           DIMTXT    140
95.           DIMCEN    141
96.           DIMTSZ    142
97.           DIMALTF   143
98.           DIMLFAC   144
99.           DIMTVP    145
100.           DIMTFAC   146
101.           DIMGAP    147
102.           DIMALTRND 148
103.           DIMALT    170
104.           DIMALTD   171
105.           DIMTOFL   172
106.           DIMSAH    173
107.           DIMTIX    174
108.           DIMSOXD   175
109.           DIMCLRD   176
110.           DIMCLRE   177
111.           DIMCLRT   178
112.           DIMADEC   179
113.           DIMDEC    271
114.           DIMTDEC   272
115.           DIMALTU   273
116.           DIMALTTD  274
117.           DIMAUNIT  275
118.           DIMFRAC   276
119.           DIMLUNIT  277
120.           DIMDSEP   278
121.           DIMATMOVE 279
122.           DIMJUST   280
123.           DIMSD1    281
124.           DIMSD2    282
125.           DIMTOLJ   283
126.           DIMTZIN   284
127.           DIMALTZ   285
128.           DIMALTTZ  286
129.           DIMUPT    288
130.           DIMATFIT  289
131.           DIMTXSTY  340
132.           DIMLDRBLK 341
133.           DIMBLK    342
134.           DIMBLK1   343
135.           DIMBLK2   344
136.           DIMLWD    371
137.           DIMLWE    372
139.         Variables have different types: these can be found in
140.         the ObjectARX Reference - search for "Dimension Style
141.         Overrides"
143.         */
145.         ResultBuffer rb =
146.           new ResultBuffer(
147.             new TypedValue[8]{
148.               new TypedValue(
149.                 (int)DxfCode.ExtendedDataRegAppName, "ACAD"
150.               ),
151.               new TypedValue(
152.                 (int)DxfCode.ExtendedDataAsciiString, "DSTYLE"
153.               ),
154.               new TypedValue(
155.                 (int)DxfCode.ExtendedDataControlString, "{"
156.               ),
157.               new TypedValue(
158.                 (int)DxfCode.ExtendedDataInteger16, 77  // DIMTAD
159.               ),
160.               new TypedValue(
161.                 (int)DxfCode.ExtendedDataInteger16, 4   // Below
162.               ),
163.               new TypedValue(
164.                 (int)DxfCode.ExtendedDataInteger16, 147 // DIMGAP
165.               ),
166.               new TypedValue(
167.                 (int)DxfCode.ExtendedDataReal, 0.5      // Larger
168.               ),
169.               new TypedValue(
170.                 (int)DxfCode.ExtendedDataControlString, "}"
171.               )
172.             }
173.           );
175.         // Set the XData on our object
177.         ad2.XData = rb;
178.         rb.Dispose();
180.         // Now let's open the current space and add our two
181.         // dimensions
183.         BlockTableRecord btr =
184.           (BlockTableRecord)tr.GetObject(
185.             db.CurrentSpaceId,
186.             OpenMode.ForWrite
187.           );
189.         btr.AppendEntity(ad1);
190.         btr.AppendEntity(ad2);
192.         tr.AddNewlyCreatedDBObject(ad1, true);
193.         tr.AddNewlyCreatedDBObject(ad2, true);
195.         // And commit the transaction, of course
197.         tr.Commit();
198.       }
199.     }
200.   }
201. }

using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.Geometry; using Autodesk.AutoCAD.Runtime; namespace DimStyleOverrideTest {   public class Commands   {     [CommandMethod("ODS")]     public void OverrideDimensionStyle()     {       Database db =         HostApplicationServices.WorkingDatabase;       Transaction tr =         db.TransactionManager.StartTransaction();       using (tr)       {         // Open our dimension style table to add our         // new dimension style         DimStyleTable dst =           (DimStyleTable)tr.GetObject(             db.DimStyleTableId, OpenMode.ForWrite           );         // Create our new dimension style         DimStyleTableRecord dstr =           new DimStyleTableRecord();         dstr.Dimtad = 2;         dstr.Dimgap = 0.3;         dstr.Name = "MyStyle";         // Add it to the dimension style table         ObjectId dsId = dst.Add(dstr);         tr.AddNewlyCreatedDBObject(dstr, true);         // Now create two identical dimensions, one         // next to the other, using our dimension         // style         AlignedDimension ad1 =           new AlignedDimension(             Point3d.Origin,             new Point3d(5.0, 0.0, 0.0),             new Point3d(2.5, 2.0, 0.0),             "Standard dimension",             dsId           );         // The only thing we change is the text string         AlignedDimension ad2 =           new AlignedDimension(             new Point3d(5.0, 0.0, 0.0),             new Point3d(10.0, 0.0, 0.0),             new Point3d(7.5, 2.0, 0.0),             "Overridden dimension",             dsId           );         /*         Now we'll add dimension overrides for DIMTAD         and DIMGAP via XData         Dimension variable group codes are:           DIMPOST     3           DIMAPOST    4           DIMSCALE   40           DIMASZ     41           DIMEXO     42           DIMDLI     43           DIMEXE     44           DIMRND     45           DIMDLE     46           DIMTP      47           DIMTM      48           DIMTOL     71           DIMLIM     72           DIMTIH     73           DIMTOH     74           DIMSE1     75           DIMSE2     76           DIMTAD     77           DIMZIN     78           DIMAZIN    79           DIMTXT    140           DIMCEN    141           DIMTSZ    142           DIMALTF   143           DIMLFAC   144           DIMTVP    145           DIMTFAC   146           DIMGAP    147           DIMALTRND 148           DIMALT    170           DIMALTD   171           DIMTOFL   172           DIMSAH    173           DIMTIX    174           DIMSOXD   175           DIMCLRD   176           DIMCLRE   177           DIMCLRT   178           DIMADEC   179           DIMDEC    271           DIMTDEC   272           DIMALTU   273           DIMALTTD  274           DIMAUNIT  275           DIMFRAC   276           DIMLUNIT  277           DIMDSEP   278           DIMATMOVE 279           DIMJUST   280           DIMSD1    281           DIMSD2    282           DIMTOLJ   283           DIMTZIN   284           DIMALTZ   285           DIMALTTZ  286           DIMUPT    288           DIMATFIT  289           DIMTXSTY  340           DIMLDRBLK 341           DIMBLK    342           DIMBLK1   343           DIMBLK2   344           DIMLWD    371           DIMLWE    372         Variables have different types: these can be found in         the ObjectARX Reference - search for "Dimension Style         Overrides"         */         ResultBuffer rb =           new ResultBuffer(             new TypedValue[8]{               new TypedValue(                 (int)DxfCode.ExtendedDataRegAppName, "ACAD"               ),               new TypedValue(                 (int)DxfCode.ExtendedDataAsciiString, "DSTYLE"               ),               new TypedValue(                 (int)DxfCode.ExtendedDataControlString, "{"               ),               new TypedValue(                 (int)DxfCode.ExtendedDataInteger16, 77  // DIMTAD               ),               new TypedValue(                 (int)DxfCode.ExtendedDataInteger16, 4   // Below               ),               new TypedValue(                 (int)DxfCode.ExtendedDataInteger16, 147 // DIMGAP               ),               new TypedValue(                 (int)DxfCode.ExtendedDataReal, 0.5      // Larger               ),               new TypedValue(                 (int)DxfCode.ExtendedDataControlString, "}"               )             }           );         // Set the XData on our object         ad2.XData = rb;         rb.Dispose();         // Now let's open the current space and add our two         // dimensions         BlockTableRecord btr =           (BlockTableRecord)tr.GetObject(             db.CurrentSpaceId,             OpenMode.ForWrite           );         btr.AppendEntity(ad1);         btr.AppendEntity(ad2);         tr.AddNewlyCreatedDBObject(ad1, true);         tr.AddNewlyCreatedDBObject(ad2, true);         // And commit the transaction, of course         tr.Commit();       }     }   } }

When we NETLOAD our application and run the ODS command, we see that two dimensions are created in the current space:

I won’t spend time on the specifics of the various dimension variables you can override using this mechanism – I’m sure many (if not most) of you know much more about AutoCAD’s dimension mechanism than I – but I have included the list of the various dimension variables’ group codes in a comment in the above code. For more information regarding the specific types of these variables – and their ranges, if applicable – I suggest searching for “Dimension Style Override” in the ObjectARX Reference.
Update
OK, I missed the obvious on this one (as does happen from time-to-time, as regular readers will by now be aware). Rather than setting the overrides directly via XData, there are handy properties belonging to the dimension’s managed interface that do this for you. Very cool. So we can reduce the code to the following:

2. using Autodesk.AutoCAD.ApplicationServices;
3. using Autodesk.AutoCAD.DatabaseServices;
4. using Autodesk.AutoCAD.EditorInput;
5. using Autodesk.AutoCAD.Geometry;
6. using Autodesk.AutoCAD.Runtime;
8. namespace DimStyleOverrideTest
9. {
10.   public class Commands
11.   {
12.     [CommandMethod("ODS")]
13.     public void OverrideDimensionStyle()
14.     {
15.       Database db =
16.         HostApplicationServices.WorkingDatabase;
18.       Transaction tr =
19.         db.TransactionManager.StartTransaction();
20.       using (tr)
21.       {
22.         // Open our dimension style table to add our
23.         // new dimension style
25.         DimStyleTable dst =
26.           (DimStyleTable)tr.GetObject(
27.             db.DimStyleTableId, OpenMode.ForWrite
28.           );
30.         // Create our new dimension style
32.         DimStyleTableRecord dstr =
33.           new DimStyleTableRecord();
34.         dstr.Dimtad = 2;
35.         dstr.Dimgap = 0.3;
36.         dstr.Name = "MyStyle";
38.         // Add it to the dimension style table
40.         ObjectId dsId = dst.Add(dstr);
41.         tr.AddNewlyCreatedDBObject(dstr, true);
43.         // Now create two identical dimensions, one
44.         // next to the other, using our dimension
45.         // style
47.         AlignedDimension ad1 =
48.           new AlignedDimension(
49.             Point3d.Origin,
50.             new Point3d(5.0, 0.0, 0.0),
51.             new Point3d(2.5, 2.0, 0.0),
52.             "Standard dimension",
53.             dsId
54.           );
56.         // The only thing we change is the text string
58.         AlignedDimension ad2 =
59.           new AlignedDimension(
60.             new Point3d(5.0, 0.0, 0.0),
61.             new Point3d(10.0, 0.0, 0.0),
62.             new Point3d(7.5, 2.0, 0.0),
63.             "Overridden dimension",
64.             dsId
65.           );
67.         // Isn't this easier?
69.         ad2.Dimtad = 4;
70.         ad2.Dimgap = 0.5;
72.         // Now let's open the current space and add our two
73.         // dimensions
75.         BlockTableRecord btr =
76.           (BlockTableRecord)tr.GetObject(
77.             db.CurrentSpaceId,
78.             OpenMode.ForWrite
79.           );
81.         btr.AppendEntity(ad1);
82.         btr.AppendEntity(ad2);
84.         tr.AddNewlyCreatedDBObject(ad1, true);
85.         tr.AddNewlyCreatedDBObject(ad2, true);
87.         // And commit the transaction, of course
89.         tr.Commit();
90.       }
91.     }
92.   }
93. }

using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.Geometry; using Autodesk.AutoCAD.Runtime; namespace DimStyleOverrideTest {   public class Commands   {     [CommandMethod("ODS")]     public void OverrideDimensionStyle()     {       Database db =         HostApplicationServices.WorkingDatabase;       Transaction tr =         db.TransactionManager.StartTransaction();       using (tr)       {         // Open our dimension style table to add our         // new dimension style         DimStyleTable dst =           (DimStyleTable)tr.GetObject(             db.DimStyleTableId, OpenMode.ForWrite           );         // Create our new dimension style         DimStyleTableRecord dstr =           new DimStyleTableRecord();         dstr.Dimtad = 2;         dstr.Dimgap = 0.3;         dstr.Name = "MyStyle";         // Add it to the dimension style table         ObjectId dsId = dst.Add(dstr);         tr.AddNewlyCreatedDBObject(dstr, true);         // Now create two identical dimensions, one         // next to the other, using our dimension         // style         AlignedDimension ad1 =           new AlignedDimension(             Point3d.Origin,             new Point3d(5.0, 0.0, 0.0),             new Point3d(2.5, 2.0, 0.0),             "Standard dimension",             dsId           );         // The only thing we change is the text string         AlignedDimension ad2 =           new AlignedDimension(             new Point3d(5.0, 0.0, 0.0),             new Point3d(10.0, 0.0, 0.0),             new Point3d(7.5, 2.0, 0.0),             "Overridden dimension",             dsId           );         // Isn't this easier?         ad2.Dimtad = 4;         ad2.Dimgap = 0.5;         // Now let's open the current space and add our two         // dimensions         BlockTableRecord btr =           (BlockTableRecord)tr.GetObject(             db.CurrentSpaceId,             OpenMode.ForWrite           );         btr.AppendEntity(ad1);         btr.AppendEntity(ad2);         tr.AddNewlyCreatedDBObject(ad1, true);         tr.AddNewlyCreatedDBObject(ad2, true);         // And commit the transaction, of course         tr.Commit();       }     }   } }

I managed to forget to name the style in the previous example, so I’ve gone ahead and fixed that in both sets of code.
And it turns out that the original question may actually have been about something different, so I’m now going to go away and look at that (and will create a new post, as needed).

雪山飞狐_lzh

十六、操纵新创建填充的绘图顺序
March 30, 2007
Manipulating the draw order of a newly created AutoCAD hatch using .NET
This question came in from Limin as a comment in this previous post:
    Is there .Net interface for autocad command "DrawOrder"? For example: after solid-hatch a polyline, need to reorder polyline and hatch, how to make it happen using .NET?
I've put together some C# code to demonstrate how to do this:

2. using Autodesk.AutoCAD.ApplicationServices;
3. using Autodesk.AutoCAD.DatabaseServices;
4. using Autodesk.AutoCAD.EditorInput;
5. using Autodesk.AutoCAD.Runtime;
6. namespace HatchDrawOrder
7. {
8.   public class Commands
9.   {
10.     [CommandMethod("HDO")]
11.     static public void HatchDrawOrder()
12.     {
13.       Document doc =
14.         Application.DocumentManager.MdiActiveDocument;
15.       Editor ed = doc.Editor;
16.       // Ask the user to select a hatch boundary
17.       PromptEntityOptions opt =
18.         new PromptEntityOptions(
19.           "\nSelect boundary: "
20.         );
21.       opt.SetRejectMessage("\nObject must be a curve.");
22.       opt.AddAllowedClass(typeof(Curve), false);
23.       PromptEntityResult res =
24.         ed.GetEntity(opt);
25.       if (res.Status == PromptStatus.OK)
26.       {
27.         Transaction tr =
28.           doc.TransactionManager.StartTransaction();
29.         using (tr)
30.         {
31.           // Check the entity is a closed curve
32.           DBObject obj =
33.             tr.GetObject(
34.               res.ObjectId,
35.               OpenMode.ForRead
36.             );
37.           Curve cur = obj as Curve;
38.           if (cur != null && cur.Closed == false)
39.           {
40.             ed.WriteMessage("\nLoop must be a closed curve.");
41.           }
42.           else
43.           {
44.             // Add the hatch to the model space
45.             BlockTable bt =
46.               (BlockTable)tr.GetObject(
47.                 doc.Database.BlockTableId,
48.                 OpenMode.ForRead
49.               );
50.             BlockTableRecord btr =
51.               (BlockTableRecord)tr.GetObject(
52.                 bt[BlockTableRecord.ModelSpace],
53.                 OpenMode.ForWrite
54.               );
55.             Hatch hat = new Hatch();
56.             hat.SetDatabaseDefaults();
57.             hat.SetHatchPattern(
58.               HatchPatternType.PreDefined,
59.               "SOLID"
60.             );
61.             ObjectId hatId = btr.AppendEntity(hat);
62.             tr.AddNewlyCreatedDBObject(hat, true);
63.             // Add the hatch loop and complete the hatch
64.             ObjectIdCollection ids =
65.               new ObjectIdCollection();
66.             ids.Add(res.ObjectId);
67.             hat.Associative = true;
68.             hat.AppendLoop(
69.               HatchLoopTypes.Default,
70.               ids
71.             );
72.             hat.EvaluateHatch(true);
73.             // Change the draworder of both hatch and loop
74.             btr.DowngradeOpen();
75.             ids.Add(hatId);
76.             DrawOrderTable dot =
77.               (DrawOrderTable)tr.GetObject(
78.                 btr.DrawOrderTableId,
79.                 OpenMode.ForWrite
80.               );
81.             dot.MoveToBottom(ids);
82.             tr.Commit();
83.           }
84.         }
85.       }
86.     }
87.   }
88. }

using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.Runtime; namespace HatchDrawOrder {   public class Commands   {     [CommandMethod("HDO")]     static public void HatchDrawOrder()     {       Document doc =         Application.DocumentManager.MdiActiveDocument;       Editor ed = doc.Editor;       // Ask the user to select a hatch boundary       PromptEntityOptions opt =         new PromptEntityOptions(           "\nSelect boundary: "         );       opt.SetRejectMessage("\nObject must be a curve.");       opt.AddAllowedClass(typeof(Curve), false);       PromptEntityResult res =         ed.GetEntity(opt);       if (res.Status == PromptStatus.OK)       {         Transaction tr =           doc.TransactionManager.StartTransaction();         using (tr)         {           // Check the entity is a closed curve           DBObject obj =             tr.GetObject(               res.ObjectId,               OpenMode.ForRead             );           Curve cur = obj as Curve;           if (cur != null && cur.Closed == false)           {             ed.WriteMessage("\nLoop must be a closed curve.");           }           else           {             // Add the hatch to the model space             BlockTable bt =               (BlockTable)tr.GetObject(                 doc.Database.BlockTableId,                 OpenMode.ForRead               );             BlockTableRecord btr =               (BlockTableRecord)tr.GetObject(                 bt[BlockTableRecord.ModelSpace],                 OpenMode.ForWrite               );             Hatch hat = new Hatch();             hat.SetDatabaseDefaults();             hat.SetHatchPattern(               HatchPatternType.PreDefined,               "SOLID"             );             ObjectId hatId = btr.AppendEntity(hat);             tr.AddNewlyCreatedDBObject(hat, true);             // Add the hatch loop and complete the hatch             ObjectIdCollection ids =               new ObjectIdCollection();             ids.Add(res.ObjectId);             hat.Associative = true;             hat.AppendLoop(               HatchLoopTypes.Default,               ids             );             hat.EvaluateHatch(true);             // Change the draworder of both hatch and loop             btr.DowngradeOpen();             ids.Add(hatId);             DrawOrderTable dot =               (DrawOrderTable)tr.GetObject(                 btr.DrawOrderTableId,                 OpenMode.ForWrite               );             dot.MoveToBottom(ids);             tr.Commit();           }         }       }     }   } }

The code to manipulate the draw order of these two entities is very simple - we have to open the DrawOrderTable for the space containing the entities we care about, and use it to change the order in which the entities are drawn. In this case I chose to send them both to the back of the draw order stack, but you might also manipulate their draw order relative to other entities in the drawing.
On a personal note, my family and I have arrived safely in Beijing - we're all a bit jet-lagged, but very happy to be here. The journey was thankfully uneventful, and with two young children that's really as much as you can hope for. :-)

雪山飞狐_lzh

十七、创建非矩形的视口
December 14, 2009
Creating non-rectangular paperspace viewports in AutoCAD using .NET
Thanks to Philippe Leefsma, from DevTech in Europe, for the ObjectARX code that inspired this post.
In AutoCAD it’s possible to create non-rectangular viewports in paperspace using a variety of closed curve objects: circles, polylines (2D, 3D and lightweight), ellipses, regions, splines and faces. In this post we’re going to see some code that creates four new viewports in the paperspace of the active drawing using a subset of these objects: an Ellipse, a Circle, a closed Spline and a closed Polyline.
Here’s the C# code:

2. using Autodesk.AutoCAD.ApplicationServices;
3. using Autodesk.AutoCAD.Runtime;
4. using Autodesk.AutoCAD.DatabaseServices;
5. using Autodesk.AutoCAD.EditorInput;
6. using Autodesk.AutoCAD.Geometry;
8. namespace ViewportCreation
9. {
10.   public class Commands
11.   {
12.     [CommandMethod("NRVPS")]
13.     static public void CreateNonRectangularViewports()
14.     {
15.       Document doc =
16.         Application.DocumentManager.MdiActiveDocument;
17.       Database db = doc.Database;
18.       Editor ed = doc.Editor;
20.       // We're accessing drawing objects, so we need a transaction
22.       Transaction tr = db.TransactionManager.StartTransaction();
23.       using (tr)
24.       {
25.         // Get the primary paperspace from the block table
27.         BlockTable bt =
28.           (BlockTable)tr.GetObject(
29.             db.BlockTableId,
30.             OpenMode.ForRead
31.           );
32.         BlockTableRecord ps =
33.           (BlockTableRecord)tr.GetObject(
34.             bt[BlockTableRecord.PaperSpace],
35.             OpenMode.ForWrite
36.           );
38.         // Create a variety of objects for our clip boundaries
40.         DBObjectCollection objs = new DBObjectCollection();
42.         // An ellipse...
44.         Ellipse el =
45.           new Ellipse(
46.             new Point3d(3.5, 4.7, 0),
47.             Vector3d.ZAxis,
48.             new Vector3d(1.4, 0.03, 0),
49.             0.35, 0, 0
50.           );
51.         objs.Add(el);
53.         // A circle...
55.         Circle cir =
56.           new Circle(
57.             new Point3d(3.4, 1.9, 0),
58.             Vector3d.ZAxis,
59.             0.9
60.           );
61.         objs.Add(cir);
63.         // A closed polyline...
65.         Polyline pl =
66.           new Polyline(6);
67.         pl.AddVertexAt(0, new Point2d(4.92, 5.29), 0, 0, 0);
68.         pl.AddVertexAt(1, new Point2d(5.16, 6.02), 0, 0, 0);
69.         pl.AddVertexAt(2, new Point2d(6.12, 6.49), 0, 0, 0);
70.         pl.AddVertexAt(3, new Point2d(7.29, 6.26), -0.27, 0, 0);
71.         pl.AddVertexAt(4, new Point2d(8.11, 5.53), -0.47, 0, 0);
72.         pl.AddVertexAt(5, new Point2d(7.75, 5.41), 0, 0, 0);
73.         pl.Closed = true;
74.         objs.Add(pl);
76.         // A closed spline...
78.         Point3dCollection pts =
79.           new Point3dCollection(
80.             new Point3d[] {
81.               new Point3d (5.5, 2.06, 0),
82.               new Point3d (5.26, 2.62, 0),
83.               new Point3d (5.66, 4.16, 0),
84.               new Point3d (8.56, 4.21, 0),
85.               new Point3d (7.2, 0.86, 0),
86.               new Point3d (6.44, 2.85, 0),
87.               new Point3d (5.62, 1.8, 0),
88.               new Point3d (5.5, 2.06, 0)
89.             }
90.           );
91.         Spline sp = new Spline(pts, 2, 0.5);
92.         objs.Add(sp);
94.         // Add each to the paperspace blocktablerecord
95.         // and create/add an associated viewport object
97.         foreach (DBObject obj in objs)
98.         {
99.           Entity ent = obj as Entity;
100.           if (ent != null)
101.           {
102.             // Add our boundary to paperspace and the
103.             // transaction
105.             ObjectId id = ps.AppendEntity(ent);
106.             tr.AddNewlyCreatedDBObject(obj, true);
108.             // Create our viewport, adding that also
110.             Viewport vp = new Viewport();
111.             ps.AppendEntity(vp);
112.             tr.AddNewlyCreatedDBObject(vp, true);
114.             // Set the boundary entity and turn the
115.             // viewport/clipping on
117.             vp.NonRectClipEntityId = id;
118.             vp.NonRectClipOn = true;
119.             vp.On = true;
120.           }
121.         }
122.         tr.Commit();
123.       }
125.       // Let's take a look at the results in paperspace
127.       db.TileMode = false;
128.     }
129.   }
130. }

using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.Geometry; namespace ViewportCreation {   public class Commands   {     [CommandMethod("NRVPS")]     static public void CreateNonRectangularViewports()     {       Document doc =         Application.DocumentManager.MdiActiveDocument;       Database db = doc.Database;       Editor ed = doc.Editor;       // We're accessing drawing objects, so we need a transaction       Transaction tr = db.TransactionManager.StartTransaction();       using (tr)       {         // Get the primary paperspace from the block table         BlockTable bt =           (BlockTable)tr.GetObject(             db.BlockTableId,             OpenMode.ForRead           );         BlockTableRecord ps =           (BlockTableRecord)tr.GetObject(             bt[BlockTableRecord.PaperSpace],             OpenMode.ForWrite           );         // Create a variety of objects for our clip boundaries         DBObjectCollection objs = new DBObjectCollection();         // An ellipse...         Ellipse el =           new Ellipse(             new Point3d(3.5, 4.7, 0),             Vector3d.ZAxis,             new Vector3d(1.4, 0.03, 0),             0.35, 0, 0           );         objs.Add(el);         // A circle...         Circle cir =           new Circle(             new Point3d(3.4, 1.9, 0),             Vector3d.ZAxis,             0.9           );         objs.Add(cir);         // A closed polyline...         Polyline pl =           new Polyline(6);         pl.AddVertexAt(0, new Point2d(4.92, 5.29), 0, 0, 0);         pl.AddVertexAt(1, new Point2d(5.16, 6.02), 0, 0, 0);         pl.AddVertexAt(2, new Point2d(6.12, 6.49), 0, 0, 0);         pl.AddVertexAt(3, new Point2d(7.29, 6.26), -0.27, 0, 0);         pl.AddVertexAt(4, new Point2d(8.11, 5.53), -0.47, 0, 0);         pl.AddVertexAt(5, new Point2d(7.75, 5.41), 0, 0, 0);         pl.Closed = true;         objs.Add(pl);         // A closed spline...         Point3dCollection pts =           new Point3dCollection(             new Point3d[] {               new Point3d (5.5, 2.06, 0),               new Point3d (5.26, 2.62, 0),               new Point3d (5.66, 4.16, 0),               new Point3d (8.56, 4.21, 0),               new Point3d (7.2, 0.86, 0),               new Point3d (6.44, 2.85, 0),               new Point3d (5.62, 1.8, 0),               new Point3d (5.5, 2.06, 0)             }           );         Spline sp = new Spline(pts, 2, 0.5);         objs.Add(sp);         // Add each to the paperspace blocktablerecord         // and create/add an associated viewport object         foreach (DBObject obj in objs)         {           Entity ent = obj as Entity;           if (ent != null)           {             // Add our boundary to paperspace and the             // transaction             ObjectId id = ps.AppendEntity(ent);             tr.AddNewlyCreatedDBObject(obj, true);             // Create our viewport, adding that also             Viewport vp = new Viewport();             ps.AppendEntity(vp);             tr.AddNewlyCreatedDBObject(vp, true);             // Set the boundary entity and turn the             // viewport/clipping on             vp.NonRectClipEntityId = id;             vp.NonRectClipOn = true;             vp.On = true;           }         }         tr.Commit();       }       // Let's take a look at the results in paperspace       db.TileMode = false;     }   } }

Here’s what happens when we draw some geometry in modelspace:

And then call the NRVPS command to create our non-rectangular viewports

lzx838

A nice little one to start the week. We’re going to ask the user to select a bunch of lines and we’ll then go through and edit each one, extending it in both directions by a quarter of its original length.
The code shows a couple of interesting techniques: aside from extending the lines themselves we also use a SelectionFilter in combination with a PromptSelectionOptions object to restrict the selection process from selecting anything but lines (and to give a customized experience by changing the selection prompt).
我也不明白KEN要写这个实例,但对于初学者来说:这也算是个不错的例子:
1>过滤选择直线对象
2>如何延长直线的长度
C#代码如下:

2.         [CommandMethod("EXL")]
3.         public void ExtendLines()
4.         {
5.             Document doc = Application.DocumentManager.MdiActiveDocument;
6.             Database db = doc.Database;
7.             Editor ed = doc.Editor;
8.             //使用一个选择对象,指定我们想选择的直线
9.             PromptSelectionOptions pso = new PromptSelectionOptions();
10.             pso.MessageForAdding = "\nSelect lines: ";
11.             TypedValue[] tvs = new TypedValue[1] { new TypedValue((int)DxfCode.Start, "LINE") };
12.             SelectionFilter sf = new SelectionFilter(tvs);
13.             //选择对象
14.             PromptSelectionResult psr = ed.GetSelection(pso, sf);
15.             if (psr.Status != PromptStatus.OK)
16.             {
17.                 return;
18.             }
19.             //当选择集不为空时
20.             if (psr.Value.Count > 0)
21.             {
22.                 //打开事务
23.                 Transaction tr = db.TransactionManager.StartTransaction();
24.                 using (tr)
25.                 {
26.                     //编辑选定的每一条直线
27.                     foreach (SelectedObject so in psr.Value)
28.                     {
29.                         //我们假定只有线的选择集
30.                         //也可以使用更多的判断办法，
31.                         //使用动态转换（Line ln = xxx as Line;）
32.                         Line ln = (Line)tr.GetObject(so.ObjectId, OpenMode.ForWrite);
33.                         //我们将直线两个方向比现在延长多四分之一
34.                         Vector3d ext = ln.Delta / 4;
35.                         // 直线起点
36.                         ln.Extend(true, ln.StartPoint - ext);
37.                         // 直线终点
38.                         ln.Extend(false, ln.EndPoint + ext);
39.                     }
40.                     //别忘记提示事务
41.                     tr.Commit();
42.                 }
43.             }
44.         }

        [CommandMethod("EXL")]         public void ExtendLines()         {             Document doc = Application.DocumentManager.MdiActiveDocument;             Database db = doc.Database;             Editor ed = doc.Editor;             //使用一个选择对象,指定我们想选择的直线             PromptSelectionOptions pso = new PromptSelectionOptions();             pso.MessageForAdding = "\nSelect lines: ";             TypedValue[] tvs = new TypedValue[1] { new TypedValue((int)DxfCode.Start, "LINE") };             SelectionFilter sf = new SelectionFilter(tvs);             //选择对象             PromptSelectionResult psr = ed.GetSelection(pso, sf);             if (psr.Status != PromptStatus.OK)             {                 return;             }             //当选择集不为空时             if (psr.Value.Count > 0)             {                 //打开事务                 Transaction tr = db.TransactionManager.StartTransaction();                 using (tr)                 {                     //编辑选定的每一条直线                     foreach (SelectedObject so in psr.Value)                     {                         //我们假定只有线的选择集                         //也可以使用更多的判断办法，                         //使用动态转换（Line ln = xxx as Line;）                         Line ln = (Line)tr.GetObject(so.ObjectId, OpenMode.ForWrite);                         //我们将直线两个方向比现在延长多四分之一                         Vector3d ext = ln.Delta / 4;                         // 直线起点                         ln.Extend(true, ln.StartPoint - ext);                         // 直线终点                         ln.Extend(false, ln.EndPoint + ext);                     }                     //别忘记提示事务                     tr.Commit();                 }             }         }

雪山飞狐_lzh

十八、块参照的剪裁Adding a 2D spatial filter to perform a simple xclip on an external reference in AutoCAD using .NET
I’ve now checked in for my flight to Las Vegas – and, thanks to Jeremy Tammik’s recent troubles, I luckily renewed my  ESTA – so I’m pretty much all set for my trip to AU 2010, at least from a travel perspective. I’m just keeping my fingers crossed that the gastric 'flu my kids seem to have come down with doesn’t hit me before I leave (or once I’m at AU… what a grim thought).

I was going to keep today’s post light, just like the last one, but then decided to dip into my email folder of externally contributed posts. This little nugget from Jamie Robertson shows how to add a simple 2D spatial filter to an external reference, effectively duplicating the XCLIP command (although this basic sample doesn’t handle non-World UCSs, block rotation/scaling, etc.).

At some point I may look at implementing a more complete version of this command, but even as it stands I have no doubt it’ll be of use to many of you. Many thanks for contributing this code, Jamie!

Here’s the C# code, with minor modifications to fit this blog:

2. using Autodesk.AutoCAD.DatabaseServices;
   
3. using Autodesk.AutoCAD.EditorInput;
   
4. using Autodesk.AutoCAD.Geometry;
   
5. using Autodesk.AutoCAD.ApplicationServices;
   
6. using Autodesk.AutoCAD.DatabaseServices.Filters;
   
7. using Autodesk.AutoCAD.Runtime;
   
8. using System;
   
9. 
   
10. 
    
11. namespace SpatialFiltering
    
12. {
    
13.   public class ClipBlock
    
14.   {
    
15.     const string filterDictName = "ACAD_FILTER";
    
16.     const string spatialName = "SPATIAL";
    
17. 
    
18.     [CommandMethod("2DXCLIP")]
    
19.     public static void clipBlockTest()
    
20.     {
    
21.       Document doc =
    
22.         Application.DocumentManager.MdiActiveDocument;
    
23.       Database db = doc.Database;
    
24.       Editor ed = doc.Editor;
    
25. 
    
26.       // Select a block to clip
    
27.       PromptEntityOptions peo =
    
28.         new PromptEntityOptions(
    
29.           "\nSelect a block reference to clip:"
    
30.         );
    
31. 
    
32.       peo.AllowNone = false;
    
33.       peo.SetRejectMessage("\nNot a block reference.");
    
34.       peo.AddAllowedClass(typeof(BlockReference), false);
    
35.       PromptEntityResult per = ed.GetEntity(peo);
    
36.       if (per.Status != PromptStatus.OK)
    
37.         return;
    
38. 
    
39.       // Select rectangle to clip
    
40.       PromptPointOptions ppo =
    
41.         new PromptPointOptions(
    
42.           "\nSelect first clip corner: "
    
43.         );
    
44. 
    
45.       ppo.AllowNone = false;
    
46.       PromptPointResult ppr = ed.GetPoint(ppo);
    
47.       if (ppr.Status != PromptStatus.OK)
    
48.         return;
    
49.       Point3d pt1 = ppr.Value;
    
50. 
    
51.       PromptCornerOptions pco =
    
52.         new PromptCornerOptions(
    
53.           "\nSelect second clip corner: ", pt1
    
54.         );
    
55. 
    
56.       ppr = ed.GetCorner(pco);
    
57.       if (ppr.Status != PromptStatus.OK)
    
58.         return;
    
59.       Point3d pt2 = ppr.Value;
    
60. 
    
61.       Transaction tr = db.TransactionManager.StartTransaction();
    
62.       using (tr)
    
63.       {
    
64.         // Transform and re-order points
    
65.         BlockReference br =
    
66.           (BlockReference)tr.GetObject(
    
67.             per.ObjectId, OpenMode.ForRead
    
68.           );
    
69. 
    
70.         pt1 = pt1.TransformBy(br.BlockTransform.Inverse());
    
71.         pt2 = pt2.TransformBy(br.BlockTransform.Inverse());
    
72.         Point2d rectMin =
    
73.           new Point2d(
    
74.             Math.Min(pt1.X, pt2.X),
    
75.             Math.Min(pt1.Y, pt2.Y)
    
76.           );
    
77. 
    
78.         Point2d rectMax =
    
79.           new Point2d(
    
80.             Math.Max(pt1.X, pt2.X),
    
81.             Math.Max(pt1.Y, pt2.Y)
    
82.           );
    
83. 
    
84.         Point2dCollection pts =
    
85.           new Point2dCollection(2){ rectMin, rectMax };
    
86.         // Create spatial filter
    
87.         // Just zeroes for the elevation and clip depths
    
88.         SpatialFilterDefinition sfd =
    
89.           new SpatialFilterDefinition(
    
90.             pts, Vector3d.ZAxis, 0.0, 0.0, 0.0, true
    
91.           );
    
92.         SpatialFilter sf = new SpatialFilter();
    
93.         sf.Definition = sfd;
    
94. 
    
95.         // Create extension dictionary if doesn't exist
    
96.         if (br.ExtensionDictionary == ObjectId.Null)
    
97.         {
    
98.           br.UpgradeOpen();
    
99.           br.CreateExtensionDictionary();
    
100.           br.DowngradeOpen();
     
101.         }
     
102. 
     
103.         // Add spatial filter to extension dictionary
     
104.         DBDictionary xDict =
     
105.           (DBDictionary)tr.GetObject(
     
106.             br.ExtensionDictionary, OpenMode.ForWrite
     
107.           );
     
108.         if (xDict.Contains(filterDictName))
     
109.         {
     
110.           DBDictionary fDict =
     
111.             (DBDictionary)tr.GetObject(
     
112.               xDict.GetAt(filterDictName), OpenMode.ForWrite
     
113.             );
     
114.           if (fDict.Contains(spatialName))
     
115.             fDict.Remove(spatialName);
     
116.           fDict.SetAt(spatialName, sf);
     
117.         }
     
118.         else
     
119.         {
     
120.           DBDictionary fDict = new DBDictionary();
     
121.           xDict.SetAt(filterDictName, fDict);
     
122.           tr.AddNewlyCreatedDBObject(fDict, true);
     
123.           fDict.SetAt(spatialName, sf);
     
124.         }
     
125.         tr.AddNewlyCreatedDBObject(sf, true);
     
126.         tr.Commit();
     
127.       }
     
128.       ed.Regen();
     
129.     }
     
130.   }
     
131. }

using Autodesk.AutoCAD.DatabaseServices;<br /> using Autodesk.AutoCAD.EditorInput;<br /> using Autodesk.AutoCAD.Geometry;<br /> using Autodesk.AutoCAD.ApplicationServices;<br /> using Autodesk.AutoCAD.DatabaseServices.Filters;<br /> using Autodesk.AutoCAD.Runtime;<br /> using System;<br /> <br /> <br /> namespace SpatialFiltering<br /> {<br />   public class ClipBlock<br />   {<br />     const string filterDictName = "ACAD_FILTER";<br />     const string spatialName = "SPATIAL";<br /> <br />     [CommandMethod("2DXCLIP")]<br />     public static void clipBlockTest()<br />     {<br />       Document doc =<br />         Application.DocumentManager.MdiActiveDocument;<br />       Database db = doc.Database;<br />       Editor ed = doc.Editor;<br /> <br />       // Select a block to clip<br />       PromptEntityOptions peo =<br />         new PromptEntityOptions(<br />           "\nSelect a block reference to clip:"<br />         );<br /> <br />       peo.AllowNone = false;<br />       peo.SetRejectMessage("\nNot a block reference.");<br />       peo.AddAllowedClass(typeof(BlockReference), false);<br />       PromptEntityResult per = ed.GetEntity(peo);<br />       if (per.Status != PromptStatus.OK)<br />         return;<br /> <br />       // Select rectangle to clip<br />       PromptPointOptions ppo =<br />         new PromptPointOptions(<br />           "\nSelect first clip corner: "<br />         );<br /> <br />       ppo.AllowNone = false;<br />       PromptPointResult ppr = ed.GetPoint(ppo);<br />       if (ppr.Status != PromptStatus.OK)<br />         return;<br />       Point3d pt1 = ppr.Value;<br /> <br />       PromptCornerOptions pco =<br />         new PromptCornerOptions(<br />           "\nSelect second clip corner: ", pt1<br />         );<br /> <br />       ppr = ed.GetCorner(pco);<br />       if (ppr.Status != PromptStatus.OK)<br />         return;<br />       Point3d pt2 = ppr.Value;<br /> <br />       Transaction tr = db.TransactionManager.StartTransaction();<br />       using (tr)<br />       {<br />         // Transform and re-order points<br />         BlockReference br =<br />           (BlockReference)tr.GetObject(<br />             per.ObjectId, OpenMode.ForRead<br />           );<br /> <br />         pt1 = pt1.TransformBy(br.BlockTransform.Inverse());<br />         pt2 = pt2.TransformBy(br.BlockTransform.Inverse());<br />         Point2d rectMin =<br />           new Point2d(<br />             Math.Min(pt1.X, pt2.X),<br />             Math.Min(pt1.Y, pt2.Y)<br />           );<br /> <br />         Point2d rectMax =<br />           new Point2d(<br />             Math.Max(pt1.X, pt2.X),<br />             Math.Max(pt1.Y, pt2.Y)<br />           );<br /> <br />         Point2dCollection pts =<br />           new Point2dCollection(2){ rectMin, rectMax };<br />         // Create spatial filter<br />         // Just zeroes for the elevation and clip depths<br />         SpatialFilterDefinition sfd =<br />           new SpatialFilterDefinition(<br />             pts, Vector3d.ZAxis, 0.0, 0.0, 0.0, true<br />           );<br />         SpatialFilter sf = new SpatialFilter();<br />         sf.Definition = sfd;<br /> <br />         // Create extension dictionary if doesn't exist<br />         if (br.ExtensionDictionary == ObjectId.Null)<br />         {<br />           br.UpgradeOpen();<br />           br.CreateExtensionDictionary();<br />           br.DowngradeOpen();<br />         }<br /> <br />         // Add spatial filter to extension dictionary<br />         DBDictionary xDict =<br />           (DBDictionary)tr.GetObject(<br />             br.ExtensionDictionary, OpenMode.ForWrite<br />           );<br />         if (xDict.Contains(filterDictName))<br />         {<br />           DBDictionary fDict =<br />             (DBDictionary)tr.GetObject(<br />               xDict.GetAt(filterDictName), OpenMode.ForWrite<br />             );<br />           if (fDict.Contains(spatialName))<br />             fDict.Remove(spatialName);<br />           fDict.SetAt(spatialName, sf);<br />         }<br />         else<br />         {<br />           DBDictionary fDict = new DBDictionary();<br />           xDict.SetAt(filterDictName, fDict);<br />           tr.AddNewlyCreatedDBObject(fDict, true);<br />           fDict.SetAt(spatialName, sf);<br />         }<br />         tr.AddNewlyCreatedDBObject(sf, true);<br />         tr.Commit();<br />       }<br />       ed.Regen();<br />     }<br />   }<br /> }

Here’s an xrefed drawing – the venerable HVAC Architectural sample drawing, no less:

And here’s the effect of running the 2DXCLIP command, selecting the Xref (the grey geometry) and a window to which to clip:

That’s it until AU – I’m looking forward to catching up with many of you in Las Vegas! :-)

雪山飞狐_lzh

July 06, 2007
Applying a gradient fill to an AutoCAD hatch using .NET
So, back in the saddle after an eventful week off, back in the UK. Aside from the extremely changeable weather (even by British standards) and the heightened security at UK airports, the week went swimmingly... :-)

It's now Friday night, and disappointingly I've spent nearly two days regaining control of my inbox. I really wanted to make a quick post before the weekend, so rather than diving into the issue I'd planned on tackling (Palettes), I decided to take a shot at a request I'd received by email a few weeks ago: to show how to create a gradient fill using .NET.

I started by reusing the code from this previous post: so much of the code I needed was there already, it had to be easy to adjust the hatch to use a gradient fill, right? Well, no - it took me much longer than I'd expected to work this one out. Maybe I should have stuck with Palettes, after all...

I decided to use a spherical gradient fill of two colours (the default colours used when you create a two-tone gradient fill using the UI), as this shows one of the trickier parts of the API, that of specifying the colours themselves. One other call it took me a while to work out was to set the HatchObjectType property - if you don't do that then you'll get an eAmbiguousOutput exception.

Here's the C# code:

1. using Autodesk.AutoCAD.ApplicationServices;
   
2. 
   
3. using Autodesk.AutoCAD.DatabaseServices;
   
4. 
   
5. using Autodesk.AutoCAD.EditorInput;
   
6. 
   
7. using Autodesk.AutoCAD.Runtime;
   
8. 
   
9. using Autodesk.AutoCAD.Colors;
   
10. 
    
11. 
    
12. 
    
13. namespace HatchGradient
    
14. 
    
15. {
    
16. 
    
17.   public class Commands
    
18. 
    
19.   {
    
20. 
    
21.     [CommandMethod("GFH")]
    
22. 
    
23.     static public void GradientFillHatch()
    
24. 
    
25.     {
    
26. 
    
27.       Document doc =
    
28. 
    
29.         Application.DocumentManager.MdiActiveDocument;
    
30. 
    
31.       Editor ed = doc.Editor;
    
32. 
    
33. 
    
34. 
    
35.       // Ask the user to select a hatch boundary
    
36. 
    
37.       PromptEntityOptions opt =
    
38. 
    
39.         new PromptEntityOptions(
    
40. 
    
41.           "\nSelect boundary: "
    
42. 
    
43.         );
    
44. 
    
45.       opt.SetRejectMessage("\nObject must be a curve.");
    
46. 
    
47.       opt.AddAllowedClass(typeof(Curve), false);
    
48. 
    
49.       PromptEntityResult res =
    
50. 
    
51.         ed.GetEntity(opt);
    
52. 
    
53. 
    
54. 
    
55.       if (res.Status == PromptStatus.OK)
    
56. 
    
57.       {
    
58. 
    
59.         Transaction tr =
    
60. 
    
61.           doc.TransactionManager.StartTransaction();
    
62. 
    
63.         using (tr)
    
64. 
    
65.         {
    
66. 
    
67.           // Check the entity is a closed curve
    
68. 
    
69.           DBObject obj =
    
70. 
    
71.             tr.GetObject(
    
72. 
    
73.               res.ObjectId,
    
74. 
    
75.               OpenMode.ForRead
    
76. 
    
77.             );
    
78. 
    
79.           Curve cur = obj as Curve;
    
80. 
    
81.           if (cur != null && cur.Closed == false)
    
82. 
    
83.           {
    
84. 
    
85.             ed.WriteMessage("\nLoop must be a closed curve.");
    
86. 
    
87.           }
    
88. 
    
89.           else
    
90. 
    
91.           {
    
92. 
    
93.             // We'll add the hatch to the model space
    
94. 
    
95.             BlockTable bt =
    
96. 
    
97.               (BlockTable)tr.GetObject(
    
98. 
    
99.                 doc.Database.BlockTableId,
    
100. 
     
101.                 OpenMode.ForRead
     
102. 
     
103.               );
     
104. 
     
105.             BlockTableRecord btr =
     
106. 
     
107.               (BlockTableRecord)tr.GetObject(
     
108. 
     
109.                 bt[BlockTableRecord.ModelSpace],
     
110. 
     
111.                 OpenMode.ForWrite
     
112. 
     
113.               );
     
114. 
     
115. 
     
116. 
     
117.             Hatch hat = new Hatch();
     
118. 
     
119.             hat.SetDatabaseDefaults();
     
120. 
     
121. 
     
122. 
     
123.             // Firstly make it clear we want a gradient fill
     
124. 
     
125.             hat.HatchObjectType =
     
126. 
     
127.               HatchObjectType.GradientObject;
     
128. 
     
129. 
     
130. 
     
131.             // Let's use the pre-defined spherical gradient
     
132. 
     
133.             hat.SetGradient(
     
134. 
     
135.               GradientPatternType.PreDefinedGradient,
     
136. 
     
137.               "SPHERICAL");
     
138. 
     
139. 
     
140. 
     
141.             // We're defining two colours
     
142. 
     
143.             hat.GradientOneColorMode = false;
     
144. 
     
145.             GradientColor[] gcs = new GradientColor[2];
     
146. 
     
147.             gcs[0] =
     
148. 
     
149.               new GradientColor(
     
150. 
     
151.                 Color.FromRgb(0, 0, 255),
     
152. 
     
153.                 0 // First colour must have value of 0
     
154. 
     
155.               );
     
156. 
     
157.             gcs[1] =
     
158. 
     
159.               new GradientColor(
     
160. 
     
161.                 Color.FromRgb(255, 255, 153),
     
162. 
     
163.                 1 // Second colour must have value of 1
     
164. 
     
165.               );
     
166. 
     
167.             hat.SetGradientColors(gcs);
     
168. 
     
169. 
     
170. 
     
171.             // Add the hatch to the model space
     
172. 
     
173.             // and the transaction
     
174. 
     
175.             ObjectId hatId = btr.AppendEntity(hat);
     
176. 
     
177.             tr.AddNewlyCreatedDBObject(hat, true);
     
178. 
     
179. 
     
180. 
     
181.             // Add the hatch loop and complete the hatch
     
182. 
     
183.             ObjectIdCollection ids =
     
184. 
     
185.               new ObjectIdCollection();
     
186. 
     
187.             ids.Add(res.ObjectId);
     
188. 
     
189.             hat.Associative = true;
     
190. 
     
191.             hat.AppendLoop(
     
192. 
     
193.               HatchLoopTypes.Default,
     
194. 
     
195.               ids
     
196. 
     
197.             );
     
198. 
     
199. 
     
200. 
     
201.             hat.EvaluateHatch(true);
     
202. 
     
203. 
     
204. 
     
205.             tr.Commit();
     
206. 
     
207.           }
     
208. 
     
209.         }
     
210. 
     
211.       }
     
212. 
     
213.     }
     
214. 
     
215.   }
     
216. 
     
217. }
     
218. 
     

using Autodesk.AutoCAD.ApplicationServices;<br /> <br /> using Autodesk.AutoCAD.DatabaseServices;<br /> <br /> using Autodesk.AutoCAD.EditorInput;<br /> <br /> using Autodesk.AutoCAD.Runtime;<br /> <br /> using Autodesk.AutoCAD.Colors;<br /> <br /> <br /> <br /> namespace HatchGradient<br /> <br /> {<br /> <br />   public class Commands<br /> <br />   {<br /> <br />     [CommandMethod("GFH")]<br /> <br />     static public void GradientFillHatch()<br /> <br />     {<br /> <br />       Document doc =<br /> <br />         Application.DocumentManager.MdiActiveDocument;<br /> <br />       Editor ed = doc.Editor;<br /> <br /> <br /> <br />       // Ask the user to select a hatch boundary<br /> <br />       PromptEntityOptions opt =<br /> <br />         new PromptEntityOptions(<br /> <br />           "\nSelect boundary: "<br /> <br />         );<br /> <br />       opt.SetRejectMessage("\nObject must be a curve.");<br /> <br />       opt.AddAllowedClass(typeof(Curve), false);<br /> <br />       PromptEntityResult res =<br /> <br />         ed.GetEntity(opt);<br /> <br /> <br /> <br />       if (res.Status == PromptStatus.OK)<br /> <br />       {<br /> <br />         Transaction tr =<br /> <br />           doc.TransactionManager.StartTransaction();<br /> <br />         using (tr)<br /> <br />         {<br /> <br />           // Check the entity is a closed curve<br /> <br />           DBObject obj =<br /> <br />             tr.GetObject(<br /> <br />               res.ObjectId,<br /> <br />               OpenMode.ForRead<br /> <br />             );<br /> <br />           Curve cur = obj as Curve;<br /> <br />           if (cur != null && cur.Closed == false)<br /> <br />           {<br /> <br />             ed.WriteMessage("\nLoop must be a closed curve.");<br /> <br />           }<br /> <br />           else<br /> <br />           {<br /> <br />             // We'll add the hatch to the model space<br /> <br />             BlockTable bt =<br /> <br />               (BlockTable)tr.GetObject(<br /> <br />                 doc.Database.BlockTableId,<br /> <br />                 OpenMode.ForRead<br /> <br />               );<br /> <br />             BlockTableRecord btr =<br /> <br />               (BlockTableRecord)tr.GetObject(<br /> <br />                 bt[BlockTableRecord.ModelSpace],<br /> <br />                 OpenMode.ForWrite<br /> <br />               );<br /> <br /> <br /> <br />             Hatch hat = new Hatch();<br /> <br />             hat.SetDatabaseDefaults();<br /> <br /> <br /> <br />             // Firstly make it clear we want a gradient fill<br /> <br />             hat.HatchObjectType =<br /> <br />               HatchObjectType.GradientObject;<br /> <br /> <br /> <br />             // Let's use the pre-defined spherical gradient<br /> <br />             hat.SetGradient(<br /> <br />               GradientPatternType.PreDefinedGradient,<br /> <br />               "SPHERICAL");<br /> <br /> <br /> <br />             // We're defining two colours<br /> <br />             hat.GradientOneColorMode = false;<br /> <br />             GradientColor[] gcs = new GradientColor[2];<br /> <br />             gcs[0] =<br /> <br />               new GradientColor(<br /> <br />                 Color.FromRgb(0, 0, 255),<br /> <br />                 0 // First colour must have value of 0<br /> <br />               );<br /> <br />             gcs[1] =<br /> <br />               new GradientColor(<br /> <br />                 Color.FromRgb(255, 255, 153),<br /> <br />                 1 // Second colour must have value of 1<br /> <br />               );<br /> <br />             hat.SetGradientColors(gcs);<br /> <br /> <br /> <br />             // Add the hatch to the model space<br /> <br />             // and the transaction<br /> <br />             ObjectId hatId = btr.AppendEntity(hat);<br /> <br />             tr.AddNewlyCreatedDBObject(hat, true);<br /> <br /> <br /> <br />             // Add the hatch loop and complete the hatch<br /> <br />             ObjectIdCollection ids =<br /> <br />               new ObjectIdCollection();<br /> <br />             ids.Add(res.ObjectId);<br /> <br />             hat.Associative = true;<br /> <br />             hat.AppendLoop(<br /> <br />               HatchLoopTypes.Default,<br /> <br />               ids<br /> <br />             );<br /> <br /> <br /> <br />             hat.EvaluateHatch(true);<br /> <br /> <br /> <br />             tr.Commit();<br /> <br />           }<br /> <br />         }<br /> <br />       }<br /> <br />     }<br /> <br />   }<br /> <br /> }<br /> <br />

Here's what you get when you run the GFH command and select a polyline boundary you've created previously:



That's it for this week - have a great weekend, all of you.