设为首页收藏本站CAD论坛CAD教程CAD下载明经币充值
切换到宽版

明经CAD社区

 找回密码
 注册

QQ登录

只需一步，快速开始

搜索
明经CAD社区»社区 › 开发篇 › AutoCAD.net/VB.net/C# 编程技术 › Kean专题(9)—Object_Properties
123下一页
返回列表 发新帖

[Kean专集] Kean专题(9)—Object_Properties

   关闭 [复制链接]
雪山飞狐_lzh
 楼主| 发表于 2009-6-1 11:20 | 显示全部楼层
九、建立一个包含文字的复杂线型
January 09, 2008
Creating a complex AutoCAD linetype containing text using .NET
In my last post we saw some code to create a simple linetype using .NET. As a comment on that post, Mark said:
Kean, i tried you code and it works great and it also got me thinking... is it possible to programmitically add text in as well? I've tried using ltr.SetTextAt(1, "TEST") but so far i've had no luck, any suggestions???
It turned out to be quite a bit more complicated to make a linetype containing text than merely calling SetTextAt() on one of the segments. In order to understand what properties needed setting, I first loaded the HOT_WATER_SUPPLY linetype from acad.lin (using the LINETYPE command):

I then looked at the contents of the linetype table using ArxDbg (the ObjectARX SDK sample that is very helpful for understanding drawing structure). Here's what the SNOOPDB command - defined by the ArxDbg application - showed for the loaded linetype:
From there it was fairly straightforward to determine the code needed to create our own complex linetype containing text segments. I decided to call the new linetype "COLD_WATER_SUPPLY", and have it resemble the original in every way but placing "CW" in the middle segment, rather than "HW" (with the descriptions updated to match, of course). As I've simply copied the properties of an existing linetype, please don't ask me to explain what they all mean. :-)
Here's the C# code:
  2. using Autodesk.AutoCAD.Runtime;
  3. using Autodesk.AutoCAD.ApplicationServices;
  4. using Autodesk.AutoCAD.DatabaseServices;
  5. using Autodesk.AutoCAD.Geometry;
  6. using Autodesk.AutoCAD.EditorInput;
  7. namespace Linetype
  8. {
  9.   public class Commands
  10.   {
  11.     [CommandMethod("CCL")]
  12.     public void CreateComplexLinetype()
  13.     {
  14.       Document doc =
  15.         Application.DocumentManager.MdiActiveDocument;
  16.       Database db = doc.Database;
  17.       Editor ed = doc.Editor;
  18.       Transaction tr =
  19.         db.TransactionManager.StartTransaction();
  20.       using (tr)
  21.       {
  22.         // We'll use the textstyle table to access
  23.         // the "Standard" textstyle for our text
  24.         // segment
  25.         TextStyleTable tt =
  26.           (TextStyleTable)tr.GetObject(
  27.             db.TextStyleTableId,
  28.             OpenMode.ForRead
  29.           );
  30.         // Get the linetype table from the drawing
  31.         LinetypeTable lt =
  32.           (LinetypeTable)tr.GetObject(
  33.             db.LinetypeTableId,
  34.             OpenMode.ForWrite
  35.           );
  36.         // Create our new linetype table record...
  37.         LinetypeTableRecord ltr =
  38.           new LinetypeTableRecord();
  39.         // ... and set its properties
  40.         ltr.Name = "COLD_WATER_SUPPLY";
  41.         ltr.AsciiDescription =
  42.           "Cold water supply ---- CW ---- CW ---- CW ----";
  43.         ltr.PatternLength = 0.9;
  44.         ltr.NumDashes = 3;
  45.         // Dash #1
  46.         ltr.SetDashLengthAt(0, 0.5);
  47.         // Dash #2
  48.         ltr.SetDashLengthAt(1, -0.2);
  49.         ltr.SetShapeStyleAt(1, tt["Standard"]);
  50.         ltr.SetShapeNumberAt(1, 0);
  51.         ltr.SetShapeOffsetAt(1, new Vector2d(-0.1,-0.05));
  52.         ltr.SetShapeScaleAt(1, 0.1);
  53.         ltr.SetShapeIsUcsOrientedAt(1, false);
  54.         ltr.SetShapeRotationAt(1, 0);
  55.         ltr.SetTextAt(1, "CW");
  56.         // Dash #3
  57.         ltr.SetDashLengthAt(2, -0.2);
  58.         // Add the new linetype to the linetype table
  59.         ObjectId ltId = lt.Add(ltr);
  60.         tr.AddNewlyCreatedDBObject(ltr, true);
  61.         // Create a test line with this linetype
  62.         BlockTable bt =
  63.           (BlockTable)tr.GetObject(
  64.             db.BlockTableId,
  65.             OpenMode.ForRead
  66.           );
  67.         BlockTableRecord btr =
  68.           (BlockTableRecord)tr.GetObject(
  69.             bt[BlockTableRecord.ModelSpace],
  70.             OpenMode.ForWrite
  71.           );
  72.         Line ln =
  73.           new Line(
  74.             new Point3d(0, 0, 0),
  75.             new Point3d(10, 10, 0)
  76.           );
  77.         ln.SetDatabaseDefaults(db);
  78.         ln.LinetypeId = ltId;
  79.         btr.AppendEntity(ln);
  80.         tr.AddNewlyCreatedDBObject(ln, true);
  81.         tr.Commit();
  82.       }
  83.     }
  84.   }
  85. }
And here's the result of calling the CCL command and zooming in on the created line:

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

x
回复 支持 反对

使用道具 举报

雪山飞狐_lzh
 楼主| 发表于 2009-6-1 11:21 | 显示全部楼层

January 11, 2008
Understanding the properties of textual linetype segments in AutoCAD
In the last post we looked at using .NET to define complex linetypes containing text segments. In the post I admitted to not knowing specifics about the properties used to create the text segment in the linetype, and, in the meantime, an old friend took pity on me and came to the rescue. :-)

Mike Kehoe, who I've known for many years since we worked together in the Guildford office of Autodesk UK, sent me some information that I've reproduced below. Mike now works for Micro Concepts Ltd., an Autodesk reseller, developer and training centre. He originally wrote the below description in the R12/12 timeframe, but apparently most of it remains valid; and while it refers to the text string used to define a linetype in a .lin file, these are also mostly properties that are exposed via the .NET interface.

Example: Using Text within a Linetype.
A,.5,-.2,["MK",STANDARD,S=.2,R=0.0,X=-0.1,Y=-.1],-.2

The key elements for defining the TEXT are as follows:

"MK" - These are the letters that will be printed along the line.

STANDARD -This tells AutoCAD what text style to apply to the text.  NB: This is optional. When no style is defined AutoCAD will use the current text style – TextStyle holds the setting for the current text style.

[Note from Kean: I found the text style to be mandatory when using the .NET interface.]

S=.2 - This is the text scaling factor. However, there are 2 options: (1) when the text style's height is 0, then S defines the height; in this case, 0.2 units; or (2) when the text style's height parameter is non-zero, the height is found by multiplying the text style's height by this number; in this case, the linetype would place the text at 20% of the height defined in the text style.

R=0.0 - This rotates the text relative to the direction of the line; e.g.: 0.0 means there is no rotation. NB: This is optional. When no rotation is defined AutoCAD will assume zero degrees. The default measurement is degrees; NB: you can use r to specify radians, g for grads, or d for degrees, such as R=150g.

[Note from Kean: just like ObjectARX, the .NET interface accepts radians for this value, in SetShapeRotationAt(). A quick reminder: 360 degrees = 2 x PI radians. So you can pass 90 degrees using "System.Math.PI / 2".]

A=0.0  - This rotates the text relative to the x-axis ("A" is short for Absolute); this ensures the text is always oriented in the same direction, no matter the direction of the line. The rotation is always performed within the text baseline and capital height. That's so that you don't get text rotated way off near the orbit of Pluto.

[Note from Kean: to use this style of rotation using .NET, you need to use SetShapeIsUcsOrientedAt() to make sure the rotation is calculated relative to the current UCS rather than the direction of the line.]

X=-0.1 - This setting moves the text just in the x-direction from the linetype definition vertex.

Y=-0.1 – This setting moves the text in the y-direction from the linetype definition vertex.
These 2 settings can be used to center the text in the line. The units are defined from the linetype scale factor, which is stored in system variable LtScale.

Thanks for the information, Mike!

回复 支持 反对

使用道具 举报

雪山飞狐_lzh
 楼主| 发表于 2009-6-5 14:01 | 显示全部楼层
本帖最后由 作者 于 2009-6-7 15:39:46 编辑

十、使用AutoCad的颜色、线型、线宽对话框
February 08, 2008
Using standard AutoCAD dialogs to select colors, linetypes and lineweights with .NET
AutoCAD has a number of handy dialogs available in the "Autodesk.AutoCAD.Windows" namespace. The following code shows how to use three, in particular: ColorDialog, LinetypeDialog and LineWeightDialog. These three classes allow you to very easily implement user-interfaces selecting their corresponding properties.
Here's the C# code:
  2. using Autodesk.AutoCAD.Runtime;
  3. using Autodesk.AutoCAD.ApplicationServices;
  4. using Autodesk.AutoCAD.DatabaseServices;
  5. using Autodesk.AutoCAD.EditorInput;
  6. using Autodesk.AutoCAD.Windows;
  7. namespace AutoCADDialogs
  8. {
  9.   public class Commands
  10.   {
  11.     [CommandMethod("CDL")]
  12.     public void ShowColorDialog()
  13.     {
  14.       Document doc =
  15.         Application.DocumentManager.MdiActiveDocument;
  16.       Database db = doc.Database;
  17.       Editor ed = doc.Editor;
  18.       ColorDialog cd = new ColorDialog();
  19.       System.Windows.Forms.DialogResult dr =
  20.         cd.ShowDialog();
  21.       if (dr == System.Windows.Forms.DialogResult.OK)
  22.       {
  23.         ed.WriteMessage(
  24.           "\nColor selected: " +
  25.           cd.Color.ToString()
  26.         );
  27.       }
  28.     }
  29.     [CommandMethod("LTDL")]
  30.     public void ShowLinetypeDialog()
  31.     {
  32.       Document doc =
  33.         Application.DocumentManager.MdiActiveDocument;
  34.       Database db = doc.Database;
  35.       Editor ed = doc.Editor;
  36.       LinetypeDialog ltd = new LinetypeDialog();
  37.       System.Windows.Forms.DialogResult dr =
  38.         ltd.ShowDialog();
  39.       if (dr == System.Windows.Forms.DialogResult.OK)
  40.       {
  41.         ed.WriteMessage(
  42.           "\nLinetype selected: " +
  43.           ltd.Linetype.ToString()
  44.         );
  45.       }
  46.     }
  47.     [CommandMethod("LWDL")]
  48.     public void ShowLineWeightDialog()
  49.     {
  50.       Document doc =
  51.         Application.DocumentManager.MdiActiveDocument;
  52.       Database db = doc.Database;
  53.       Editor ed = doc.Editor;
  54.       LineWeightDialog lwd = new LineWeightDialog();
  55.       System.Windows.Forms.DialogResult dr =
  56.         lwd.ShowDialog();
  57.       if (dr == System.Windows.Forms.DialogResult.OK)
  58.       {
  59.         ed.WriteMessage(
  60.           "\nLineweight selected: " +
  61.           lwd.LineWeight.ToString()
  62.         );
  63.       }
  64.     }
  65.   }
  66. }
When we run the CDL command, we have three tabs available:



Here's the dialog shown by the LTDL command:

And the LWDL command:

And here is the command-line output for selecting each of the above items:
  1. Command: CDL
  2. Color selected: 91
  3. Command: CDL
  4. Color selected: 56,166,199
  5. Command: CDL
  6. Color selected: DIC 266
  7. Command: LTDL
  8. Linetype selected: (2130316464)
  9. Command: LWDL
  10. Lineweight selected: LineWeight009
复制代码
In the next post we'll look at at how to use these dialogs in a more realistic way.


本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

x
回复 支持 反对

使用道具 举报

雪山飞狐_lzh
 楼主| 发表于 2009-6-5 14:02 | 显示全部楼层
February 12, 2008
Modifying the color, linetype and lineweight of an AutoCAD entity using standard dialogs from .NET
In the last post we saw code to display and use AutoCAD's built-in colour, linetype and lineweight dialogs. In this post we extend that by using each of them in sequence to display various properties of an entity, allowing the user to modify them.
While this is slightly more "real world" than the last post, it doesn't really make sense to implement a command such as the one below (the property palette is much better, for instance :-). The main purpose is to show how to set the initial values in the various dialogs and afterwards to make use of the values the user selects.
Here's the C# code:
  2. using Autodesk.AutoCAD.Runtime;
  3. using Autodesk.AutoCAD.ApplicationServices;
  4. using Autodesk.AutoCAD.DatabaseServices;
  5. using Autodesk.AutoCAD.EditorInput;
  6. using Autodesk.AutoCAD.Windows;
  7. namespace EntityProperties
  8. {
  9.   public class Commands
  10.   {
  11.     [CommandMethod("SPE")]
  12.     public void SetPropertiesOnEntity()
  13.     {
  14.       Document doc =
  15.         Application.DocumentManager.MdiActiveDocument;
  16.       Database db = doc.Database;
  17.       Editor ed = doc.Editor;
  18.       PromptEntityResult per =
  19.         ed.GetEntity(
  20.           "\nSelect entity to modify: "
  21.         );
  22.       if (per.Status != PromptStatus.OK)
  23.         return;
  24.       Transaction tr =
  25.         db.TransactionManager.StartTransaction();
  26.       using (tr)
  27.       {
  28.         Entity ent =
  29.           (Entity)
  30.             tr.GetObject(
  31.               per.ObjectId,
  32.               OpenMode.ForRead
  33.             );
  34.         ColorDialog cd = new ColorDialog();
  35.         cd.Color = ent.Color;
  36.         System.Windows.Forms.DialogResult dr;
  37.         dr = cd.ShowDialog();
  38.         if (dr != System.Windows.Forms.DialogResult.OK)
  39.           return;
  40.         LinetypeDialog ltd = new LinetypeDialog();
  41.         ltd.Linetype = ent.LinetypeId;
  42.         dr = ltd.ShowDialog();
  43.         if (dr != System.Windows.Forms.DialogResult.OK)
  44.           return;
  45.         LineWeightDialog lwd = new LineWeightDialog();
  46.         lwd.LineWeight = ent.LineWeight;
  47.         dr = lwd.ShowDialog();
  48.         if (dr != System.Windows.Forms.DialogResult.OK)
  49.           return;
  50.         ent.UpgradeOpen();
  51.         if (ent.Color != cd.Color)
  52.           ent.Color = cd.Color;
  53.         if (ent.LinetypeId != ltd.Linetype)
  54.           ent.LinetypeId = ltd.Linetype;
  55.         if (ent.LineWeight != lwd.LineWeight)
  56.           ent.LineWeight = lwd.LineWeight;
  57.         tr.Commit();
  58.       }
  59.     }
  60.   }
  61. }
Notice that we "return" from the code in a number of places, should the user cancel one of the dialogs. This is perfectly safe, as we're "using" the transaction object, and once it leaves scope it will automatically be disposed (and therefore aborted).
Running the SPE command will display in sequence the dialogs shown in the previous post, and use the user's input to change the state of the selected entity.

回复 支持 反对

使用道具 举报

雪山飞狐_lzh
 楼主| 发表于 2009-6-5 14:03 | 显示全部楼层
本帖最后由 作者 于 2009-6-7 16:10:16 编辑

十一、在AutoCad2009中使用新的.NetApi从文件中提取XML数据
April 07, 2008
Extracting XML data from drawings using a new .NET API in AutoCAD 2009
This post is the latest in the series of closer looks at the new APIs in AutoCAD 2009. It covers the Data Extraction API, a new .NET API allowing you to drive the Data Extraction feature inside AutoCAD.
There is a very thorough C# sample included on the ObjectARX SDK (under samples/dotNet/DataExtraction), so I thought I'd focus on a much simpler example where we extract data from a single drawing.
Here's the C# code:
  2. using System.Collections.Generic;
  3. using Autodesk.AutoCAD.ApplicationServices;
  4. using Autodesk.AutoCAD.EditorInput;
  5. using Autodesk.AutoCAD.Runtime;
  6. using Autodesk.AutoCAD.DataExtraction;
  7. namespace DataExtraction
  8. {
  9.   public class Commands
  10.   {
  11.     const string path =
  12.       @"c:\Program Files\Autodesk\AutoCAD 2009\Sample";
  13.     const string fileName =
  14.       "Visualization - Aerial.dwg";
  15.     const string outputXmlFile =
  16.       @"c:\temp\data-extract.xml";
  17.     [CommandMethod("extd")]
  18.     public void extractData()
  19.     {
  20.       if (!System.IO.File.Exists(path + fileName))
  21.       {
  22.         Document doc =
  23.           Application.DocumentManager.MdiActiveDocument;
  24.         Editor ed =
  25.           doc.Editor;
  26.         ed.WriteMessage("\nFile does not exist.");
  27.         return;
  28.       }
  29.       // Create some settings for the extraction
  30.       IDxExtractionSettings es =
  31.         new DxExtractionSettings();
  32.       IDxDrawingDataExtractor de =
  33.         es.DrawingDataExtractor;
  34.       de.Settings.ExtractFlags =
  35.         ExtractFlags.ModelSpaceOnly |
  36.         ExtractFlags.XrefDependent |
  37.         ExtractFlags.Nested;
  38.       // Add a single file to the settings
  39.       IDxFileReference fr =
  40.         new DxFileReference(path, path + fileName);
  41.       de.Settings.DrawingList.AddFile(fr);
  42.       // Scan the drawing for object types & their properties
  43.       de.DiscoverTypesAndProperties(path);
  44.       List<IDxTypeDescriptor> types =
  45.         de.DiscoveredTypesAndProperties;
  46.       // Select all the types and properties for extraction
  47.       // by adding them one-by-one to these two lists
  48.       List<string> selTypes = new List<string>();
  49.       List<string> selProps = new List<string>();
  50.       foreach (IDxTypeDescriptor type in types)
  51.       {
  52.         selTypes.Add(type.GlobalName);
  53.         foreach (
  54.           IDxPropertyDescriptor pr in type.Properties
  55.         )
  56.         {
  57.           if (!selProps.Contains(pr.GlobalName))
  58.             selProps.Add(pr.GlobalName);
  59.         }
  60.       }
  61.       // Pass this information to the extractor
  62.       de.Settings.SetSelectedTypesAndProperties(
  63.         types,
  64.         selTypes,
  65.         selProps
  66.       );
  67.       // Now perform the extraction itself
  68.       de.ExtractData(path);
  69.       // Get the results of the extraction
  70.       System.Data.DataTable dataTable =
  71.         de.ExtractedData;
  72.       // Output the extracted data to an XML file
  73.       if (dataTable.Rows.Count > 0)
  74.       {
  75.         dataTable.TableName = "My_Data_Extract";
  76.         dataTable.WriteXml(outputXmlFile);
  77.       }
  78.     }
  79.   }
  80. }
Here are the first few objects from the output file found in c:\temp\data-extract.xml after running the EXTD command:
  2. <?xml version="1.0" standalone="yes"?>
  3. <DocumentElement>
  4.   <My_Data_Extract>
  5.     <AcDxHandleData>183</AcDxHandleData>
  6.     <Layer>0</Layer>
  7.     <LinetypeScale>1</LinetypeScale>
  8.     <PlotStyleName>ByLayer</PlotStyleName>
  9.     <LineWeight>ByLayer</LineWeight>
  10.     <Material>Material 3</Material>
  11.     <Linetype>ByLayer</Linetype>
  12.     <Color>ByLayer</Color>
  13.     <AcDxObjectTypeName>3D Solid</AcDxObjectTypeName>
  14.     <AcDxObjectTypeGlobalName>
  15.       Autodesk.AutoCAD.DatabaseServices.Solid3d
  16.     </AcDxObjectTypeGlobalName>
  17.     <AcDxDwgSummaryDwgName>
  18.       Visualization - Aerial.dwg
  19.     </AcDxDwgSummaryDwgName>
  20.     <AcDxDwgSummaryDwgLocation>
  21.       c:\Program Files\Autodesk\AutoCAD 2009\Sample
  22.     </AcDxDwgSummaryDwgLocation>
  23.     <AcDxDwgSummaryDwgSize>472480</AcDxDwgSummaryDwgSize>
  24.     <AcDxDwgSummaryDwgCreated>
  25.       2007-01-03T00:44:20+01:00
  26.     </AcDxDwgSummaryDwgCreated>
  27.     <AcDxDwgSummaryDwgModified>
  28.       2007-01-03T00:44:20+01:00
  29.     </AcDxDwgSummaryDwgModified>
  30.     <AcDxDwgSummaryDwgAccessed>
  31.       2008-03-03T11:40:53.796875+01:00
  32.     </AcDxDwgSummaryDwgAccessed>
  33.     <AcDxDwgSummaryDwgTitle />
  34.     <AcDxDwgSummaryDwgSubject />
  35.     <AcDxDwgSummaryDwgAuthor />
  36.     <AcDxDwgSummaryDwgKeywords />
  37.     <AcDxDwgSummaryDwgComments />
  38.     <AcDxDwgSummaryDwgHyperLinkBase />
  39.     <AcDxDwgSummaryDwgLastSavedBy>
  40.       thompsl
  41.     </AcDxDwgSummaryDwgLastSavedBy>
  42.     <AcDxDwgSummaryDwgRevisionNumber />
  43.     <AcDxDwgSummaryDwgTotalEditingTime>
  44.       1179
  45.     </AcDxDwgSummaryDwgTotalEditingTime>
  46.     <AcDxEntityHyperlink />
  47.   </My_Data_Extract>
  48.   <My_Data_Extract>
  49.     <AcDxHandleData>191</AcDxHandleData>
  50.     <Layer>0</Layer>
  51.     <LinetypeScale>1</LinetypeScale>
  52.     <PlotStyleName>ByLayer</PlotStyleName>
  53.     <LineWeight>ByLayer</LineWeight>
  54.     <Material>Material 3</Material>
  55.     <Linetype>ByLayer</Linetype>
  56.     <Color>ByLayer</Color>
  57.     <AcDxObjectTypeName>3D Solid</AcDxObjectTypeName>
  58.     <AcDxObjectTypeGlobalName>
  59.       Autodesk.AutoCAD.DatabaseServices.Solid3d
  60.     </AcDxObjectTypeGlobalName>
  61.     <AcDxDwgSummaryDwgName>
  62.       Visualization - Aerial.dwg
  63.     </AcDxDwgSummaryDwgName>
  64.     <AcDxDwgSummaryDwgLocation>
  65.       c:\Program Files\Autodesk\AutoCAD 2009\Sample
  66.     </AcDxDwgSummaryDwgLocation>
  67.     <AcDxDwgSummaryDwgSize>472480</AcDxDwgSummaryDwgSize>
  68.     <AcDxDwgSummaryDwgCreated>
  69.       2007-01-03T00:44:20+01:00
  70.     </AcDxDwgSummaryDwgCreated>
  71.     <AcDxDwgSummaryDwgModified>
  72.       2007-01-03T00:44:20+01:00
  73.     </AcDxDwgSummaryDwgModified>
  74.     <AcDxDwgSummaryDwgAccessed>
  75.       2008-03-03T11:40:53.796875+01:00
  76.     </AcDxDwgSummaryDwgAccessed>
  77.     <AcDxDwgSummaryDwgTitle />
  78.     <AcDxDwgSummaryDwgSubject />
  79.     <AcDxDwgSummaryDwgAuthor />
  80.     <AcDxDwgSummaryDwgKeywords />
  81.     <AcDxDwgSummaryDwgComments />
  82.     <AcDxDwgSummaryDwgHyperLinkBase />
  83.     <AcDxDwgSummaryDwgLastSavedBy>
  84.       thompsl
  85.     </AcDxDwgSummaryDwgLastSavedBy>
  86.     <AcDxDwgSummaryDwgRevisionNumber />
  87.     <AcDxDwgSummaryDwgTotalEditingTime>
  88.       1179
  89.     </AcDxDwgSummaryDwgTotalEditingTime>
  90.     <AcDxEntityHyperlink />
  91.   </My_Data_Extract>
  92.   <!-- Stuff deleted from the XML output -->
  93.   <!-- ... -->
  94. </DocumentElement>

回复 支持 反对

使用道具 举报

雪山飞狐_lzh
 楼主| 发表于 2009-6-5 14:05 | 显示全部楼层
本帖最后由 作者 于 2009-6-7 16:11:06 编辑

十二、图层过滤器
July 11, 2008
Adding and removing AutoCAD layer filters using .NET
This question came in by email last week:
The last two days I am struggling with adding a new LayerGroup to HostApplicationServices.WorkingDatabase.LayerFilters.Root. I simply cannot get it working. Is it possible to write a blog item with example on this?
An interesting question and it can indeed be quite tricky to understand how this works. For those of you who are ADN members, here's a DevNote covering the basics, which I've taken and extended for this post.
When working with LayerFilters, it's important to know that the Database property providing access to the list of current LayerFilters does so by value (i.e. you have to get a copy of the current set of LayerFilters, manipulate it, and then set it back on the Database object to have them picked up by the system).
The below C# code implements commands to list the existing layer filters (LLFS), create three new layer filters (CLFS), and delete a layer filter selected by the user (DLF):
  2. using Autodesk.AutoCAD.ApplicationServices;
  3. using Autodesk.AutoCAD.DatabaseServices;
  4. using Autodesk.AutoCAD.EditorInput;
  5. using Autodesk.AutoCAD.Runtime;
  6. using Autodesk.AutoCAD.LayerManager;
  7. namespace LayerFilters
  8. {
  9.   public class Commands
  10.   {
  11.     [CommandMethod("LLFS")]
  12.     static public void ListLayerFilters()
  13.     {
  14.       Document doc =
  15.         Application.DocumentManager.MdiActiveDocument;
  16.       Database db = doc.Database;
  17.       Editor ed = doc.Editor;
  18.       // List the nested layer filters
  19.       LayerFilterCollection lfc =
  20.         db.LayerFilters.Root.NestedFilters;
  21.       for (int i = 0; i < lfc.Count; ++i)
  22.       {
  23.         LayerFilter lf = lfc[i];
  24.         ed.WriteMessage(
  25.           "\n{0} - {1} (can{2} be deleted)",
  26.           i + 1,
  27.           lf.Name,
  28.           (lf.AllowDelete ? "" : "not")
  29.         );
  30.       }
  31.     }
  32.     [CommandMethod("CLFS")]
  33.     static public void CreateLayerFilters()
  34.     {
  35.       Document doc =
  36.         Application.DocumentManager.MdiActiveDocument;
  37.       Database db = doc.Database;
  38.       Editor ed = doc.Editor;
  39.       try
  40.       {
  41.         // Get the existing layer filters
  42.         // (we will add to them and set them back)
  43.         LayerFilterTree lft =
  44.           db.LayerFilters;
  45.         LayerFilterCollection lfc =
  46.           lft.Root.NestedFilters;
  47.         // Create three new layer filters
  48.         LayerFilter lf1 = new LayerFilter();
  49.         lf1.Name = "Unlocked Layers";
  50.         lf1.FilterExpression = "LOCKED=="False"";
  51.         LayerFilter lf2 = new LayerFilter();
  52.         lf2.Name = "White Layers";
  53.         lf2.FilterExpression = "COLOR=="7"";
  54.         LayerFilter lf3 = new LayerFilter();
  55.         lf3.Name = "Visible Layers";
  56.         lf3.FilterExpression =
  57.           "OFF=="False" AND FROZEN=="False"";
  58.         // Add them to the collection
  59.         lfc.Add(lf1);
  60.         lfc.Add(lf2);
  61.         lfc.Add(lf3);
  62.         // Set them back on the Database
  63.         db.LayerFilters = lft;
  64.         // List the layer filters, to see the new ones
  65.         ListLayerFilters();
  66.       }
  67.       catch (Exception ex)
  68.       {
  69.         ed.WriteMessage(
  70.           "\nException: {0}",
  71.           ex.Message
  72.         );
  73.       }
  74.     }
  75.     [CommandMethod("DLF")]
  76.     static public void DeleteLayerFilter()
  77.     {
  78.       Document doc =
  79.         Application.DocumentManager.MdiActiveDocument;
  80.       Database db = doc.Database;
  81.       Editor ed = doc.Editor;
  82.       ListLayerFilters();
  83.       try
  84.       {
  85.         // Get the existing layer filters
  86.         // (we will add to them and set them back)
  87.         LayerFilterTree lft =
  88.           db.LayerFilters;
  89.         LayerFilterCollection lfc =
  90.           lft.Root.NestedFilters;
  91.         // Prompt for the index of the filter to delete
  92.         PromptIntegerOptions pio =
  93.           new PromptIntegerOptions(
  94.           "\n\nEnter index of filter to delete"
  95.           );
  96.         pio.LowerLimit = 1;
  97.         pio.UpperLimit = lfc.Count;
  98.         PromptIntegerResult pir =
  99.           ed.GetInteger(pio);
  100.         // Get the selected filter
  101.         LayerFilter lf = lfc[pir.Value - 1];
  102.         // If it's possible to delete it, do so
  103.         if (!lf.AllowDelete)
  104.         {
  105.           ed.WriteMessage(
  106.             "\nLayer filter cannot be deleted."
  107.           );
  108.         }
  109.         else
  110.         {
  111.           lfc.Remove(lf);
  112.           db.LayerFilters = lft;
  113.           ListLayerFilters();
  114.         }
  115.       }
  116.       catch(Exception ex)
  117.       {
  118.         ed.WriteMessage(
  119.           "\nException: {0}",
  120.           ex.Message
  121.         );
  122.       }
  123.     }
  124.   }
  125. }
Here's what happens when we run the various commands:
  1. Command: LLFS
  2. 1 - All Used Layers (cannot be deleted)
  3. 2 - Unreconciled New Layers (cannot be deleted)
  4. 3 - Viewport Overrides (cannot be deleted)
  5. Command: CLFS
  6. 1 - Unlocked Layers (can be deleted)
  7. 2 - White Layers (can be deleted)
  8. 3 - Visible Layers (can be deleted)
  9. 4 - All Used Layers (cannot be deleted)
  10. 5 - Unreconciled New Layers (cannot be deleted)
  11. 6 - Viewport Overrides (cannot be deleted)
  12. Command: DLF
  13. 1 - Unlocked Layers (can be deleted)
  14. 2 - White Layers (can be deleted)
  15. 3 - Visible Layers (can be deleted)
  16. 4 - All Used Layers (cannot be deleted)
  17. 5 - Unreconciled New Layers (cannot be deleted)
  18. 6 - Viewport Overrides (cannot be deleted)
  19. Enter index of filter to delete: 1
  20. 1 - White Layers (can be deleted)
  21. 2 - Visible Layers (can be deleted)
  22. 3 - All Used Layers (cannot be deleted)
  23. 4 - Unreconciled New Layers (cannot be deleted)
  24. 5 - Viewport Overrides (cannot be deleted)
复制代码
You can see the three new filters (before you delete any with the DLF command) in the LAYER dialog. To see them work, create a bunch of layers, changing the colour of some and turning off/freezing/locking others:

回复 支持 反对

使用道具 举报

雪山飞狐_lzh
 楼主| 发表于 2009-6-7 16:08 | 显示全部楼层
September 24, 2008
Creating a layer group inside AutoCAD using .NET
The following question came in as a comment on this previous post:
Your example above shows how to create a property type filter, how do you add layers to a group type filter (LayerGroup class)? I can create the group filter but can't figure out how to add layers to the group. The filterexpression method is available but doesn't seem to work (at least not like with the LayerFilter object)
To tackle this, let's start by looking at the documentation on the LayerGroup class in the .NET Reference (currently part of the ObjectARX Reference):
LayerGroup is derived from LayerFilter and serves as the access to layer group filters. It allows the client to specify and retrieve a set of layer IDs. The filter() method returns true if the object ID of the given layer is contained in the set of layer IDs for the LayerGroup.
Specifying the filter criteria is done solely by using LayerId. LayerGroup doesn't use a filter expression string, so FilterExpression and FilterExpressionTree return a null pointer.
The recommended way of identifying LayerGroup filters in a group of layer filters is to query the IsIdFilter property, which returns true for an LayerGroup.
So, at the root of the question, we need to create a LayerGroup and add the ObjectIds of the LayerTableRecords we wish to include in the group to its LayerIds property.
I started by taking the code in the post referred to above and extended it to contain a new CLG command to Create a Layer Group. This command lists the available layers for the user to select from, and creates a layer group containing the selected layers.
Here's the updated C# code - pay particular attention to the new CLG command, of course:
  2. using Autodesk.AutoCAD.ApplicationServices;
  3. using Autodesk.AutoCAD.DatabaseServices;
  4. using Autodesk.AutoCAD.EditorInput;
  5. using Autodesk.AutoCAD.Runtime;
  6. using Autodesk.AutoCAD.LayerManager;
  7. using System.Collections.Generic;
  8. namespace LayerFilters
  9. {
  10.   public class Commands
  11.   {
  12.     [CommandMethod("LLFS")]
  13.     static public void ListLayerFilters()
  14.     {
  15.       Document doc =
  16.         Application.DocumentManager.MdiActiveDocument;
  17.       Database db = doc.Database;
  18.       Editor ed = doc.Editor;
  19.       // List the nested layer filters
  20.       LayerFilterCollection lfc =
  21.         db.LayerFilters.Root.NestedFilters;
  22.       for (int i = 0; i < lfc.Count; ++i)
  23.       {
  24.         LayerFilter lf = lfc[i];
  25.         ed.WriteMessage(
  26.           "\n{0} - {1} (can{2} be deleted)",
  27.           i + 1,
  28.           lf.Name,
  29.           (lf.AllowDelete ? "" : "not")
  30.         );
  31.       }
  32.     }
  33.     [CommandMethod("CLFS")]
  34.     static public void CreateLayerFilters()
  35.     {
  36.       Document doc =
  37.         Application.DocumentManager.MdiActiveDocument;
  38.       Database db = doc.Database;
  39.       Editor ed = doc.Editor;
  40.       try
  41.       {
  42.         // Get the existing layer filters
  43.         // (we will add to them and set them back)
  44.         LayerFilterTree lft =
  45.           db.LayerFilters;
  46.         LayerFilterCollection lfc =
  47.           lft.Root.NestedFilters;
  48.         // Create three new layer filters
  49.         LayerFilter lf1 = new LayerFilter();
  50.         lf1.Name = "Unlocked Layers";
  51.         lf1.FilterExpression = "LOCKED=="False"";
  52.         LayerFilter lf2 = new LayerFilter();
  53.         lf2.Name = "White Layers";
  54.         lf2.FilterExpression = "COLOR=="7"";
  55.         LayerFilter lf3 = new LayerFilter();
  56.         lf3.Name = "Visible Layers";
  57.         lf3.FilterExpression =
  58.           "OFF=="False" AND FROZEN=="False"";
  59.         // Add them to the collection
  60.         lfc.Add(lf1);
  61.         lfc.Add(lf2);
  62.         lfc.Add(lf3);
  63.         // Set them back on the Database
  64.         db.LayerFilters = lft;
  65.         // List the layer filters, to see the new ones
  66.         ListLayerFilters();
  67.       }
  68.       catch (Exception ex)
  69.       {
  70.         ed.WriteMessage(
  71.           "\nException: {0}",
  72.           ex.Message
  73.         );
  74.       }
  75.     }
  76.     [CommandMethod("CLG")]
  77.     static public void CreateLayerGroup()
  78.     {
  79.       Document doc =
  80.         Application.DocumentManager.MdiActiveDocument;
  81.       Database db = doc.Database;
  82.       Editor ed = doc.Editor;
  83.       // A list of the layers' names & IDs contained
  84.       // in the current database, sorted by layer name
  85.       SortedList<string, ObjectId> ld =
  86.         new SortedList<string, ObjectId>();
  87.       // A list of the selected layers' IDs
  88.       ObjectIdCollection lids =
  89.         new ObjectIdCollection();
  90.       // Start by populating the list of names/IDs
  91.       // from the LayerTable
  92.       Transaction tr =
  93.         db.TransactionManager.StartTransaction();
  94.       using (tr)
  95.       {
  96.         LayerTable lt =
  97.           (LayerTable)tr.GetObject(
  98.             db.LayerTableId,
  99.             OpenMode.ForRead
  100.           );
  101.         foreach(ObjectId lid in lt)
  102.         {
  103.           LayerTableRecord ltr =
  104.             (LayerTableRecord)tr.GetObject(
  105.               lid,
  106.               OpenMode.ForRead
  107.           );
  108.           ld.Add(ltr.Name, lid);
  109.         }
  110.       }
  111.       // Display a numbered list of the available layers
  112.       ed.WriteMessage("\nLayers available for group:");
  113.       int i = 1;
  114.       foreach (KeyValuePair<string,ObjectId> kv in ld)
  115.       {
  116.         ed.WriteMessage(
  117.           "\n{0} - {1}",
  118.           i++,
  119.           kv.Key
  120.         );
  121.       }
  122.       // We will ask the user to select from the list
  123.       PromptIntegerOptions pio =
  124.         new PromptIntegerOptions(
  125.           "\nEnter number of layer to add: "
  126.         );
  127.       pio.LowerLimit = 1;
  128.       pio.UpperLimit = ld.Count;
  129.       pio.AllowNone = true;
  130.       // And will do so in a loop, waiting for
  131.       // Escape or Enter to terminate
  132.       PromptIntegerResult pir;
  133.       do
  134.       {
  135.         // Select one from the list
  136.         pir = ed.GetInteger(pio);
  137.         if (pir.Status == PromptStatus.OK)
  138.         {
  139.           // Get the layer's name
  140.           string ln =
  141.             ld.Keys[pir.Value-1];
  142.           // And then its ID
  143.           ObjectId lid;
  144.           ld.TryGetValue(ln, out lid);
  145.           // Add the layer'd ID to the list, is it's not
  146.           // already on it
  147.           if (lids.Contains(lid))
  148.           {
  149.             ed.WriteMessage(
  150.               "\nLayer "{0}" has already been selected.",
  151.               ln
  152.             );
  153.           }
  154.           else
  155.           {
  156.             lids.Add(lid);
  157.             ed.WriteMessage(
  158.               "\nAdded "{0}" to selected layers.",
  159.               ln
  160.             );
  161.           }
  162.         }
  163.       } while (pir.Status == PromptStatus.OK);
  164.       // Now we've selected our layers, let's create the group
  165.       try
  166.       {
  167.         if (lids.Count > 0)
  168.         {
  169.           // Get the existing layer filters
  170.           // (we will add to them and set them back)
  171.           LayerFilterTree lft =
  172.             db.LayerFilters;
  173.           LayerFilterCollection lfc =
  174.             lft.Root.NestedFilters;
  175.           // Create a new layer group
  176.           LayerGroup lg = new LayerGroup();
  177.           lg.Name = "My Layer Group";
  178.           // Add our layers' IDs to the list
  179.           foreach (ObjectId id in lids)
  180.             lg.LayerIds.Add(id);
  181.           // Add the group to the collection
  182.           lfc.Add(lg);
  183.           // Set them back on the Database
  184.           db.LayerFilters = lft;
  185.           ed.WriteMessage(
  186.             "\n"{0}" group created containing {1} layers.\n",
  187.             lg.Name,
  188.             lids.Count
  189.           );
  190.           // List the layer filters, to see the new group
  191.           ListLayerFilters();
  192.         }
  193.       }
  194.       catch (Exception ex)
  195.       {
  196.         ed.WriteMessage(
  197.           "\nException: {0}",
  198.           ex.Message
  199.         );
  200.       }
  201.     }
  202.     [CommandMethod("DLF")]
  203.     static public void DeleteLayerFilter()
  204.     {
  205.       Document doc =
  206.         Application.DocumentManager.MdiActiveDocument;
  207.       Database db = doc.Database;
  208.       Editor ed = doc.Editor;
  209.       ListLayerFilters();
  210.       try
  211.       {
  212.         // Get the existing layer filters
  213.         // (we will add to them and set them back)
  214.         LayerFilterTree lft =
  215.           db.LayerFilters;
  216.         LayerFilterCollection lfc =
  217.           lft.Root.NestedFilters;
  218.         // Prompt for the index of the filter to delete
  219.         PromptIntegerOptions pio =
  220.           new PromptIntegerOptions(
  221.           "\n\nEnter index of filter to delete"
  222.           );
  223.         pio.LowerLimit = 1;
  224.         pio.UpperLimit = lfc.Count;
  225.         PromptIntegerResult pir =
  226.           ed.GetInteger(pio);
  227.         // Get the selected filter
  228.         LayerFilter lf = lfc[pir.Value - 1];
  229.         // If it's possible to delete it, do so
  230.         if (!lf.AllowDelete)
  231.         {
  232.           ed.WriteMessage(
  233.             "\nLayer filter cannot be deleted."
  234.           );
  235.         }
  236.         else
  237.         {
  238.           lfc.Remove(lf);
  239.           db.LayerFilters = lft;
  240.           ListLayerFilters();
  241.         }
  242.       }
  243.       catch(Exception ex)
  244.       {
  245.         ed.WriteMessage(
  246.           "\nException: {0}",
  247.           ex.Message
  248.         );
  249.       }
  250.     }
  251.   }
  252. }
Here's what happens when we run the code on a drawing containing a number of layers (all of which have the default properties for new layers):
  1. Command: CLG
  2. Layers available for group:
  3. 1 - 0
  4. 2 - Layer1
  5. 3 - Layer2
  6. 4 - Layer3
  7. 5 - Layer4
  8. 6 - Layer5
  9. 7 - Layer6
  10. 8 - Layer7
  11. 9 - Layer8
  12. 10 - Layer9
  13. 11 - Test1
  14. 12 - Test2
  15. 13 - Test3
  16. 14 - Test4
  17. 15 - Test5
  18. Enter number of layer to add: 2
  19. Added "Layer1" to selected layers.
  20. Enter number of layer to add: 4
  21. Added "Layer3" to selected layers.
  22. Enter number of layer to add: 6
  23. Added "Layer5" to selected layers.
  24. Enter number of layer to add: 8
  25. Added "Layer7" to selected layers.
  26. Enter number of layer to add: 11
  27. Added "Test1" to selected layers.
  28. Enter number of layer to add: 15
  29. Added "Test5" to selected layers.
  30. Enter number of layer to add:
  31. "My Layer Group" group created containing 6 layers.
  32. 1 - My Layer Group (can be deleted)
  33. 2 - All Used Layers (cannot be deleted)
  34. 3 - Unreconciled New Layers (cannot be deleted)
  35. 4 - Viewport Overrides (cannot be deleted)
复制代码
I've hard-coded the name of the new layer group to be "My Layer Group". It's a trivial exercise to modify the code to ask the user to enter a name, each time.
Here is how our new group looks in AutoCAD's Layer dialog:

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

x
回复 支持 反对

使用道具 举报

雪山飞狐_lzh
 楼主| 发表于 2009-6-7 16:24 | 显示全部楼层
十三、向.NetApi开放AutoCAD中的属性面板的功能
OPM & 例子


March 13, 2009
Exposing AutoCAD's Properties Palette functionality to .NET - Part 1
A huge thanks to Cyrille Fauvel, who manages DevTech's Media & Entertainment team but still finds the time to dip into the odd deeply-technical, AutoCAD-related issue. Cyrille provided the original article on this topic late last year, but it's taken me time to get around to editing and publishing it. A quick tip... if you're not interested in the technical details of how Cyrille has exposed the various Properties Palette interfaces to .NET, you can safely skip this post and join us again when we go ahead and make use of the implementation to add dynamic properties to core AutoCAD objects using C#. Most people won't want to know all the details included in this post, but are just interested in the end results: next time I'll be providing a pre-built ObjectARX module, along with full source-code, that can be loaded into AutoCAD 2007-2009 to enable the use of the Properties Palette from .NET.
AutoCAD's Properties Palette - once known as the Object Properties Manager (OPM) - is a very handy way to display properties inside your application, whether those properties are associated with individual objects or with the application itself. The Properties Palette uses COM to communicate with the object(s) in question, and has always required the use of C++ to expose particular interfaces that control the display of the properties in the palette, so its functionality has not been available to developers using managed .NET languages such as C# and VB.NET.
There is some portion of the Properties Palette functionality exposed via the Autodesk.AutoCAD.Windows.ToolPalette namespace, such as the IAcPiPropertyDisplay interface allowing objects and commands to customize the display of properties in the property inspector window, but this is far from complete. This post looks at exposing more of the standard Properties Palette functionality to .NET languages, and next time we'll look at some specific examples of using it from C#.
Our first step is to expose some "OPM" interfaces to .NET. There are two ways to do this: we can expose them from our .NET application sung standard C# or VB.NET code, or we can use a small ObjectARX module to implement them.
Well, we have to use ObjectARX to access some OPM functionality that is currently only exposed via C++, so we're going to go down that path. What we're going to do is expose the interface(s) we want from our ObjectARX module and marshal the various parameters to be useable from .NET. Simple! :-)
To get started, we're going to look at AutoCAD's IPropertyManager2 interface, which is contained in dynprops.h on the ObjectARX SDK:
  2. //--------------------------
  3. // IPropertyManager2 interface
  4. // This is the main property manager class. Use this to add your
  5. // property classes for a given type of IUnknown object.
  6. // You can get this interface using
  7. // CreateOPMIUnknownProtocol(ppUnk)->GetPropertyManager2().
  8. //--------------------------
  9. // {FABC1C70-1044-4aa0-BF8D-91FFF9052715}
  10. DEFINE_GUID(IID_IPropertyManager2, 0xfabc1c70, 0x1044, 0x4aa0, 0xbf, 0x8d, 0x91, 0xff, 0xf9, 0x5, 0x27, 0x15);
  12. interface DECLSPEC_UUID("FABC1C70-1044-4aa0-BF8D-91FFF9052715")
  13. IPropertyManager2 : public IUnknown
  14. {
  15.     BEGIN_INTERFACE
  16.     // *** IUnknown methods ****
  17.     STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE;
  18.     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
  19.     STDMETHOD_(ULONG, Release)(THIS) PURE;
  21.     // *** IPropertyManager2 methods ***
  22.     STDMETHOD(AddProperty)(THIS_ IUnknown FAR* pDynPropObj) PURE;
  23.     STDMETHOD(RemoveProperty)(THIS_ IUnknown FAR* pDynPropObj) PURE;
  24.     STDMETHOD(GetDynamicProperty)(THIS_ /*[in]*/LONG index,
  25.                                     /*[out]*/IUnknown ** pDynPropObj) PURE;
  26.     STDMETHOD(GetDynamicPropertyByName)(THIS_ /*[in]*/BSTR propName,
  27.                                           /*[out]*/IUnknown ** pDynPropObj) PURE;
  28.     STDMETHOD(GetDynamicPropertyCountEx)(THIS_ /*[out]*/LONG* count) PURE;
  29.     //For COM Wrappers to generate dynamic property typeinfo
  30.     STDMETHOD(GetDynamicClassInfo)(THIS_ /*[in]*/IUnknown* pObj,
  31.                                         /*[out]*/ITypeInfo** pptiDynamic,
  32.                                         /*[out]*/DWORD* dwCookie) PURE;
  33. };
Now in our ObjectARX application we're going to expose the IPropertyManager2 interface to .NET.
At line 41 in the IPropertyManager2.h file in the provided project [which will actually be provided with the final post of the series], we declare the interface using the same Global Unique Identifier (GUID):
[InteropServices::Guid("FABC1C70-1044-4aa0-BF8D-91FFF9052715")]
Then we need to indicate that our interface is derived from the standard, root COM interface, IUnknown:
[InteropServices::InterfaceTypeAttribute(InteropServices::ComInterfaceType::InterfaceIsIUnknown)]
We make it visible to COM, of course:
[InteropServices::ComVisible(true)]
Now for the interface itself. We declare that it's a "public interface class" along with its various members, specifying how to marshal all the types. We're not going to return values from our methods (which usually indicate success or failure): we'll leave it to the .NET code that implements the interfaces (which we'll see in the final post of the series) to throw exceptions instead.
Here's the full class declaration, edited for display on this blog:
  2. namespace Autodesk
  3. {
  4.   namespace AutoCAD
  5.   {
  6.     namespace Windows
  7.     {
  8.       namespace OPM
  9.       {
  10.         [InteropServices::Guid(
  11.           "FABC1C70-1044-4aa0-BF8D-91FFF9052715"
  12.         )]
  13.         [InteropServices::InterfaceTypeAttribute(
  14.           InteropServices::ComInterfaceType::InterfaceIsIUnknown
  15.         )]
  16.         [InteropServices::ComVisible(true)]
  18.         public interface class IPropertyManager2
  19.         {
  20.           void AddProperty(
  21.             [InteropServices::In,
  22.               InteropServices::MarshalAs(
  23.                 InteropServices::UnmanagedType::IUnknown
  24.               )
  25.             ] Object^ pDynPropObj
  26.           );
  27.           void RemoveProperty(
  28.             [InteropServices::In,
  29.               InteropServices::MarshalAs(
  30.                 InteropServices::UnmanagedType::IUnknown
  31.               )
  32.             ] Object^ pDynPropObj
  33.           );
  34.           void GetDynamicProperty(
  35.             [InteropServices::In] long index,
  36.             [InteropServices::Out,
  37.               InteropServices::MarshalAs(
  38.                 InteropServices::UnmanagedType::IUnknown
  39.               )
  40.             ] interior_ptr<Object^> value
  41.           );
  42.           void GetDynamicPropertyByName(
  43.             [InteropServices::In,
  44.               InteropServices::MarshalAs(
  45.                 InteropServices::UnmanagedType::BStr
  46.               )
  47.             ] System::String^ name,
  48.             [InteropServices::Out,
  49.               InteropServices::MarshalAs(
  50.                 InteropServices::UnmanagedType::IUnknown
  51.               )
  52.             ] interior_ptr<Object^> value
  53.           );
  54.           void GetDynamicPropertyCountEx(
  55.             [InteropServices::Out] long* count
  56.             );
  57.           void GetDynamicClassInfo(
  58.             [InteropServices::In,
  59.               InteropServices::MarshalAs(
  60.                 InteropServices::UnmanagedType::IUnknown
  61.               )
  62.             ] Object^ pDynPropObj,
  63.             [InteropServices::Out,
  64.               InteropServices::MarshalAs(
  65.                 /*InteropServices::UnmanagedType::ITypeInfo*/
  66.                 InteropServices::UnmanagedType::IUnknown
  67.               )
  68.             ] interior_ptr<Object^> typeInfo,
  69.             [InteropServices::Out] ulong* dwCookie
  70.           );
  71.         };
  72.       }
  73.     }
  74.   }
  75. }
This one class is really at the core of our effort to expose the OPM to .NET. To let us access and use this class, we're going to expose a "property extension factory". We might have opted to P/Invoke an ObjectARX API for this, but it's ultimately cleaner to implement this from C++ and expose it via a managed wrapper.
So how do we know we need a property extension factory? Typically to access the IPropertyManager2 instance from ObjectARX we use the GET_OPMPROPERTY_MANAGER() macro. From dynprops.h, we know that this macro expands into GET_OPMEXTENSION_CREATE_PROTOCOL()->CreateOPMObjectProtocol(pAcRxClass)->GetPropertyManager() and the GET_OPMEXTENSION_CREATE_PROTOCOL() macro expands, in turn, into OPMPropertyExtensionFactory::cast(AcDbDatabase::desc()->queryX(OPMPropertyExtensionFactory::desc())). This is how we know we need to expose the OPMPropertyExtensionFactory class.
So let's take a look at the declaration in the ObjectARX SDK of OPMPropertyExtensionFactory, once again from dynprops.h:
  1. //--------------------------
  2. // OPMPropertyExtension interface
  3. // This class is implemented by AutoCAD and available through
  4. // GET_OPMEXTENSION_CREATE_PROTOCOL. You can add property classes
  5. // by calling GET_OPMPROPERTY_MANAGER for a particular AcRxClass
  6. // to get the property manager for that class.
  7. // You can also enumerate the dynamic properties which have
  8. // been added to that class as well as its base class(es) via
  9. // GetPropertyCount and GetPropertyClassArray
  10. //--------------------------
  11. class OPMPropertyExtensionFactory: public AcRxObject
  12. {
  13. public:
  14.     ACRX_DECLARE_MEMBERS(OPMPropertyExtensionFactory);
  15.     virtual ~OPMPropertyExtensionFactory(){}
  17.     //Retrieves the OPMPropertyExtension for the specified class, if the
  18.     //extension has not been added before, it creates it. Note: the implementation
  19.     //of this class manages the lifetime of OPMPropertyExtension, as such you don't
  20.     //need to delete them.
  21.     virtual OPMPropertyExtension* CreateOPMObjectProtocol(AcRxClass* pClass,
  22.                                                             LONG lReserved = NULL) = 0;
  24. ...
  25. }
复制代码
To expose this class through .NET we're going to use the Autodesk::AutoCAD::Runtime::Wrapper attribute class to tell AutoCAD to manage this class as an internal class object wrapper. We then derive our wrapper class from RXObject (as the base class of the corresponding ObjectARX class is AcRxObject), and implement a constructor, a GetImpObj() method to provide access to the unmanaged object and our factory function itself, CreateOPMObjectProtocol(). There's no need for a destructor as this is handled by the wrapper.
Here's the complete class declaration from OPMPropertyExtensionFactory.h in the provided sample:
  2. namespace Autodesk
  3. {
  4.   namespace AutoCAD
  5.   {
  6.     namespace Windows
  7.     {
  8.       namespace OPM
  9.       {
  10.         [Autodesk::AutoCAD::Runtime::Wrapper(
  11.           "OPMPropertyExtensionFactory"
  12.         )]
  13.         public ref class AcMgdOPMPropertyExtensionFactory
  14.           : public RXObject
  15.         {
  16.         public protected:
  17.           AcMgdOPMPropertyExtensionFactory(
  18.             System::IntPtr unmanagedPointer,
  19.             bool bAutoDelete
  20.           )
  21.             : RXObject(unmanagedPointer, bAutoDelete) {}
  23.         internal:
  24.           //- Returns the unmanaged ARX Object
  25.           inline OPMPropertyExtensionFactory* GetImpObj()
  26.           {
  27.             return(
  28.               static_cast<OPMPropertyExtensionFactory *>(
  29.                 UnmanagedObject.ToPointer()
  30.               )
  31.             );
  32.           }
  34.         public:
  35.           virtual AcMgdOPMPropertyExtension^ CreateOPMObjectProtocol(
  36.             RXClass^ runtimeClass,
  37.             long lReserved
  38.           );
  39.         } ;
  40.       }
  41.     }
  42.   }
  43. }
There is one last class that needs to be exposed: OPMPropertyExtension, which is what is created by the OPMPropertyExtensionFactory (logically enough). We'll use the same technique as for the OPMPropertyExtensionFactory.
Here's the class declaration from OPMPropertyExtension.h:
  2. namespace Autodesk
  3. {
  4.   namespace AutoCAD
  5.   {
  6.     namespace Windows
  7.     {
  8.       namespace OPM
  9.       {
  10.         [Autodesk::AutoCAD::Runtime::Wrapper(
  11.           "OPMPropertyExtension"
  12.         )]
  13.         public ref class AcMgdOPMPropertyExtension : public RXObject
  14.         {
  15.         public protected:
  16.           AcMgdOPMPropertyExtension(
  17.             System::IntPtr unmanagedPointer,
  18.             bool bAutoDelete
  19.           )
  20.             : RXObject (unmanagedPointer, bAutoDelete) {}
  22.         internal:
  23.           //- Returns the unmanaged ARX Object
  24.           inline OPMPropertyExtension* GetImpObj()
  25.           {
  26.             return (
  27.               static_cast<OPMPropertyExtension *>(
  28.                 UnmanagedObject.ToPointer()
  29.               )
  30.             );
  31.           }
  33.         public:
  34.           virtual Object^ GetPropertyManager();
  35.           virtual void SetPropertyManager(Object^ pPropManager);
  36.         } ;
  37.       }
  38.     }
  39.   }
  40. }
Those are all the declarations (yes, in C++ you need declare your classes separately from their definitions... yawn... :-) so let's go ahead and implement the wrapper classes.
First the OPMPropertyExtensionFactory class (from OPMPropertyExtensionFactory.cpp), with it's main method to create and return a new OPMPropertyExtension:
  2. namespace Autodesk
  3. {
  4.   namespace AutoCAD
  5.   {
  6.     namespace Windows
  7.     {
  8.       namespace OPM
  9.       {
  10.         AcMgdOPMPropertyExtension^
  11.           AcMgdOPMPropertyExtensionFactory::CreateOPMObjectProtocol(
  12.             RXClass^ runtimeClass, long lReserved
  13.           )
  14.         {
  15.           return (
  16.             gcnew AcMgdOPMPropertyExtension(
  17.               System::IntPtr(
  18.                 GetImpObj()->CreateOPMObjectProtocol(
  19.                   static_cast<AcRxClass*>(
  20.                     //runtimeClass->GetImpObj()
  21.                     runtimeClass->UnmanagedObject.ToPointer()
  22.                   ),
  23.                   lReserved
  24.                 )
  25.               ),
  26.               false
  27.             )
  28.           );
  29.         }
  30.       }
  31.     }
  32.   }
  33. }
Here's the implementation of the OPMPropertyExtension class (from OPMPropertyExtension.cpp), which gets us access to the OPMPropertyManager:
  2. namespace Autodesk
  3. {
  4.   namespace AutoCAD
  5.   {
  6.     namespace Windows
  7.     {
  8.       namespace OPM
  9.       {
  10.         Object^ AcMgdOPMPropertyExtension::GetPropertyManager()
  11.         {
  12.           IUnknown *pUnk =
  13.             GetImpObj()->GetPropertyManager();
  14.           return (
  15.             System::Runtime::InteropServices::Marshal::
  16.             GetObjectForIUnknown(System::IntPtr(pUnk))
  17.           );
  18.         }
  20.         void AcMgdOPMPropertyExtension::SetPropertyManager(
  21.           Object^ pPropManager
  22.         )
  23.         {
  24.           IPropertyManager *pPropMgr =
  25.             reinterpret_cast<IPropertyManager *>(
  26.               System::Runtime::InteropServices::Marshal::
  27.               GetIUnknownForObject(pPropManager).ToPointer()
  28.             );
  29.           GetImpObj()->SetPropertyManager(pPropMgr);
  30.         }
  31.       }
  32.     }
  33.   }
  34. }
To finish off our implementation, we're going to re-implement the two handy macros we have in unmanaged C++ (i.e. ObjectARX), to give us the same capabilities when in a managed environment.
Here's our implementation from xOPM.cpp:
  2. namespace Autodesk
  3. {
  4.   namespace AutoCAD
  5.   {
  6.     namespace Windows
  7.     {
  8.       namespace OPM
  9.       {
  10.         AcMgdOPMPropertyExtensionFactory^
  11.           xOPM::xGET_OPMEXTENSION_CREATE_PROTOCOL()
  12.         {
  13.           Dictionary^ classDict =
  14.             SystemObjects::ClassDictionary;
  15.           RXClass^ opmFactoryClass =
  16.             (RXClass^)classDict->At("OPMPropertyExtensionFactory");
  17.           RXClass^ dbClass =
  18.             (RXClass^)classDict->At("AcDbDatabase");
  19.           return(
  20.             gcnew AcMgdOPMPropertyExtensionFactory(
  21.               dbClass->QueryX (opmFactoryClass),
  22.               false
  23.             )
  24.           );
  25.         }
  27.         Object^
  28.           xOPM::xGET_OPMPROPERTY_MANAGER(RXClass^ pAcRxClass)
  29.         {
  30.           AcMgdOPMPropertyExtensionFactory^ opmFactory =
  31.             xOPM::xGET_OPMEXTENSION_CREATE_PROTOCOL();
  32.           return(
  33.             opmFactory->
  34.               CreateOPMObjectProtocol(pAcRxClass, 0)->
  35.                 GetPropertyManager());
  36.         }
  37.       }
  38.     }
  39.   }
  40. }
There's just one more interface that needs exposing to .NET, and that's IDynamicProperty2. We're going to expose this in much the same way as we did IPropertyManager2.
Here's the original declaration from dynprops.h:
  1. //--------------------------
  2. // IDynamicProperty2 interface
  3. // Implement this class to create dynamic properties for the PropertyPalette
  4. // it defines the base set of property attributes as well as
  5. // the name/type/data tuples.
  6. //--------------------------
  7. // {9CAF41C2-CA86-4ffb-B05A-AC43C424D076}
  8. DEFINE_GUID(IID_IDynamicProperty2, 0x9caf41c2, 0xca86, 0x4ffb, 0xb0, 0x5a, 0xac, 0x43, 0xc4, 0x24, 0xd0, 0x76);
  10. interface DECLSPEC_UUID("9CAF41C2-CA86-4ffb-B05A-AC43C424D076")
  11. IDynamicProperty2 : public IUnknown
  12. {
  13.     BEGIN_INTERFACE
  14.     // *** IUnknown methods ****
  16.     STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE;
  17.     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
  18.     STDMETHOD_(ULONG, Release)(THIS) PURE;
  20.     // *** IDynamicProperty2 methods ***
  21.     //Unique property ID
  22.     STDMETHOD(GetGUID)(THIS_ /*[out]*/GUID* propGUID) PURE;
  23.     // Property display name
  24.     STDMETHOD(GetDisplayName)(THIS_ /*[out]*/BSTR* bstrName) PURE;
  25.     // Show/Hide property in the OPM, for this object instance
  26.     STDMETHOD(IsPropertyEnabled)(THIS_ /*[in]*/IUnknown *pUnk,
  27.                                       /*[out]*/BOOL* pbEnabled) PURE;
  28.     // Is property showing but disabled
  29.     STDMETHOD(IsPropertyReadOnly)(THIS_ /*[out]*/BOOL* pbReadonly) PURE;
  30.     // Get the property description string
  31.     STDMETHOD(GetDescription)(THIS_ /*[out]*/BSTR* bstrName) PURE;
  33.     // *** Basic property value information ***
  34.     // OPM will typically display these in an edit field
  36.     // optional: meta data representing property type name, ex. ACAD_ANGLE
  37.     STDMETHOD(GetCurrentValueName)(THIS_ /*[out]*/BSTR* pbstrName) PURE;
  38.     // What is the property type, ex. VT_R8
  39.     STDMETHOD(GetCurrentValueType)(THIS_ /*[out]*/VARTYPE* pVarType) PURE;
  40.     // Get the property value, passes the specific object we need the property
  41.     // value for.
  42.     STDMETHOD(GetCurrentValueData)(THIS_ /*in*/IUnknown *pUnk,
  43.                                       /*[out]*/VARIANT* pvarData) PURE;
  44.     // Set the property value, passes the specific object we want to set the
  45.     // property value for
  46.     STDMETHOD(SetCurrentValueData)(THIS_ /*[in]*/IUnknown *pUnk,
  47.                                         /*[in]*/const VARIANT varData) PURE;
  49.     //*** Notifications ***
  50.     //OPM passes its implementation of IDynamicPropertyNotify, you
  51.     //cache it and call it to inform OPM your property has changed
  52.     STDMETHOD(Connect)(THIS_ /*[in]*/IDynamicPropertyNotify2* pSink) PURE;
  53.     STDMETHOD(Disconnect)(THIS_ ) PURE;
  54. };
复制代码
And here's our own exposure of this interface to .NET (from IDynamicProperty2.h):
  2. namespace Autodesk
  3. {
  4.   namespace AutoCAD
  5.   {
  6.     namespace Windows
  7.     {
  8.       namespace OPM
  9.       {
  10.         [InteropServices::Guid(
  11.           "9CAF41C2-CA86-4ffb-B05A-AC43C424D076"
  12.         )]
  13.         [InteropServices::InterfaceTypeAttribute(
  14.           InteropServices::ComInterfaceType::InterfaceIsIUnknown
  15.         )]
  16.         [InteropServices::ComVisible(true)]
  17.         public interface class IDynamicProperty2
  18.         {
  19.           void GetGUID(
  20.             [InteropServices::Out] System::Guid% propGUID
  21.           );
  22.           void GetDisplayName(
  23.             [InteropServices::Out,
  24.             InteropServices::MarshalAs(
  25.               InteropServices::UnmanagedType::BStr
  26.             )
  27.             ] interior_ptr<System::String^> name);
  28.           void IsPropertyEnabled(
  29.             [InteropServices::In,
  30.             InteropServices::MarshalAs(
  31.               InteropServices::UnmanagedType::IUnknown
  32.             )
  33.             ] Object^ pUnk,
  34.             [InteropServices::Out] System::Int32% bEnabled
  35.           );
  36.           void IsPropertyReadOnly(
  37.             [InteropServices::Out] System::Int32% bReadonly
  38.           );
  39.           void GetDescription(
  40.             [InteropServices::Out,
  41.             InteropServices::MarshalAs(
  42.               InteropServices::UnmanagedType::BStr
  43.             )
  44.             ] interior_ptr<System::String^> description
  45.           );
  46.           void GetCurrentValueName(
  47.             [InteropServices::Out,
  48.             InteropServices::MarshalAs(
  49.               InteropServices::UnmanagedType::BStr
  50.             )
  51.             ] interior_ptr<System::String^> name
  52.           );
  53.           void GetCurrentValueType(
  54.             [InteropServices::Out] ushort% pVarType
  55.           );
  56.           void GetCurrentValueData(
  57.             [InteropServices::In,
  58.             InteropServices::MarshalAs(
  59.               InteropServices::UnmanagedType::IUnknown
  60.             )
  61.             ] Object^ pUnk,
  62.             [InteropServices::In,
  63.             InteropServices::Out,
  64.             InteropServices::MarshalAs(
  65.               InteropServices::UnmanagedType::Struct
  66.             )
  67.             ] interior_ptr<Object^> varData
  68.           );
  69.           void SetCurrentValueData(
  70.             [InteropServices::In,
  71.             InteropServices::MarshalAs(
  72.               InteropServices::UnmanagedType::IUnknown
  73.             )
  74.             ] Object^ pUnk,
  75.             [InteropServices::In,
  76.             InteropServices::MarshalAs(
  77.               InteropServices::UnmanagedType::Struct
  78.             )
  79.             ] Object^ varData
  80.           );
  81.           void Connect(
  82.             [InteropServices::In,
  83.             InteropServices::MarshalAs(
  84.               /*IDynamicPropertyNotify2*/
  85.               InteropServices::UnmanagedType::IUnknown
  86.             )
  87.             ] Object^ pSink
  88.           );
  89.           void Disconnect();
  90.         };
  91.         [InteropServices::Guid(
  92.           "975112B5-5403-4197-AFB8-90C6CA73B9E1"
  93.         )]
  94.         [InteropServices::InterfaceTypeAttribute(
  95.           InteropServices::ComInterfaceType::InterfaceIsIUnknown
  96.         )]
  97.         [InteropServices::ComVisible(true)]
  98.         public interface class IDynamicPropertyNotify2
  99.         {
  100.           void OnChanged(
  101.             [InteropServices::In,
  102.             InteropServices::MarshalAs(
  103.               InteropServices::UnmanagedType::IUnknown
  104.             )
  105.             ] Object^ pDynamicProperty
  106.           );
  107.           void GetCurrentSelectionSet(
  108.             [InteropServices::In,
  109.             InteropServices::Out,
  110.             InteropServices::MarshalAs(
  111.               InteropServices::UnmanagedType::Struct
  112.             )
  113.             ] interior_ptr<Object^> pSelection
  114.           );
  115.         };
  116.       }
  117.     }
  118.   }
  119. }
OK, that's it for the hardcore technical details on exposing AutoCAD's Properties Palette to .NET. In the next post we'll start the real fun with some real examples of using these interfaces from C# (and you can trust me when I say that's going to be a whole lot simpler than this post, honestly! :-).

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

x
回复 支持 反对

使用道具 举报

雪山飞狐_lzh
 楼主| 发表于 2009-6-7 16:27 | 显示全部楼层
March 16, 2009
Exposing AutoCAD's Properties Palette functionality to .NET - Part 2
In the last post we looked at the code behind an ObjectARX module exposing AutoCAD's Properties Palette for use from managed .NET languages. Thanks again to Cyrille Fauvel for providing this implementation. In this post we're going to move right onto using this implementation from C#.
First things first: if you didn't understand much of what was said in the previous post in this series, Don't Panic! (Yes, that's a quick reference to  The Hitchhiker's Guide to the Galaxy.) The actual implementation details aren't particularly important - you only really need to understand them if you want to expose additional interfaces to .NET in the same way (such as IFilterableProperty, the interface discussed in this previous post and something I expect to extend the application to handle, at some point).
Here is the project that contains both the ObjectARX module implementing exposing these interfaces and the sample we're showing today. You simply have to make sure the .NET module can find our asdkOPMNetExt.dll module (ideally both this and your .NET module should be located under AutoCAD's program folder).
Then you can simply implement code, as in the below sample, which loads and makes use of interfaces exposed by this assembly.
Here’s the C# code:
  2. using Autodesk.AutoCAD.ApplicationServices;
  3. using Autodesk.AutoCAD.Runtime;
  4. using Autodesk.AutoCAD.Windows.OPM;
  5. using System;
  6. using System.Reflection;
  7. using System.Runtime.InteropServices;
  9. namespace OPMNetSample
  10. {
  11.   #region Our Custom Property
  12.   [
  13.     Guid("F60AE3DA-0373-4d24-82D2-B2646517ABCB"),
  14.     ProgId("OPMNetSample.CustomProperty.1"),
  16.     // No class interface is generated for this class and
  17.     // no interface is marked as the default.
  18.     // Users are expected to expose functionality through
  19.     // interfaces that will be explicitly exposed by the object
  20.     // This means the object can only expose interfaces we define
  22.     ClassInterface(ClassInterfaceType.None),
  23.     // Set the default COM interface that will be used for
  24.     // Automation. Languages like: C#, C++ and VB allow to
  25.     //query for interface's we're interested in but Automation
  26.     // only aware languages like javascript do not allow to
  27.     // query interface(s) and create only the default one
  29.     ComDefaultInterface(typeof(IDynamicProperty2)),
  30.     ComVisible(true)
  31.   ]
  32.   public class CustomProp : IDynamicProperty2
  33.   {
  34.     private IDynamicPropertyNotify2 m_pSink = null;
  36.     // Unique property ID
  38.     public void GetGUID(out Guid propGUID)
  39.     {
  40.       propGUID =
  41.         new Guid("F60AE3DA-0373-4d24-82D2-B2646517ABCB");
  42.     }
  44.     // Property display name
  46.     public void GetDisplayName(out string szName)
  47.     {
  48.       szName = "My integer property";
  49.     }
  51.     // Show/Hide property in the OPM, for this object instance
  53.     public void IsPropertyEnabled(object pUnk, out int bEnabled)
  54.     {
  55.       bEnabled = 1;
  56.     }
  58.     // Is property showing but disabled
  60.     public void IsPropertyReadOnly(out int bReadonly)
  61.     {
  62.       bReadonly = 0;
  63.     }
  65.     // Get the property description string
  67.     public void GetDescription(out string szName)
  68.     {
  69.       szName =
  70.         "This property is an integer";
  71.     }
  73.     // OPM will typically display these in an edit field
  74.     // optional: meta data representing property type name,
  75.     // ex. ACAD_ANGLE
  77.     public void GetCurrentValueName(out string szName)
  78.     {
  79.       throw new System.NotImplementedException();
  80.     }
  82.     // What is the property type, ex. VT_R8
  84.     public void GetCurrentValueType(out ushort varType)
  85.     {
  86.       // The Property Inspector supports the following data
  87.       // types for dynamic properties:
  88.       // VT_I2, VT_I4, VT_R4, VT_R8,VT_BSTR, VT_BOOL
  89.       // and VT_USERDEFINED.
  91.       varType = 3; // VT_I4
  92.     }
  94.     // Get the property value, passes the specific object
  95.     // we need the property value for.
  97.     public void GetCurrentValueData(object pUnk, ref object pVarData)
  98.     {
  99.       // TODO: Get the value and return it to AutoCAD
  101.       // Because we said the value type was a 32b int (VT_I4)
  102.       pVarData = (int)4;
  103.     }
  105.     // Set the property value, passes the specific object we
  106.     // want to set the property value for
  108.     public void SetCurrentValueData(object pUnk, object varData)
  109.     {
  110.       // TODO: Save the value returned to you
  112.       // Because we said the value type was a 32b int (VT_I4)
  113.       int myVal = (int)varData;
  114.     }
  116.     // OPM passes its implementation of IDynamicPropertyNotify, you
  117.     // cache it and call it to inform OPM your property has changed
  119.     public void Connect(object pSink)
  120.     {
  121.       m_pSink = (IDynamicPropertyNotify2)pSink;
  122.     }
  124.     public void Disconnect() {
  125.       m_pSink = null;
  126.     }
  127.   }
  128.   #endregion
  130.   #region Application Entry Point
  131.   public class MyEntryPoint : IExtensionApplication
  132.   {
  133.     protected internal CustomProp custProp = null;
  135.     public void Initialize()
  136.     {
  137.       Assembly.LoadFrom("asdkOPMNetExt.dll");
  139.       // Add the Dynamic Property
  141.       Dictionary classDict = SystemObjects.ClassDictionary;
  142.       RXClass lineDesc = (RXClass)classDict.At("AcDbLine");
  143.       IPropertyManager2 pPropMan =
  144.         (IPropertyManager2)xOPM.xGET_OPMPROPERTY_MANAGER(lineDesc);
  146.       custProp = new CustomProp();
  147.       pPropMan.AddProperty((object)custProp);
  148.     }
  150.     public void Terminate()
  151.     {
  152.       // Remove the Dynamic Property
  154.       Dictionary classDict = SystemObjects.ClassDictionary;
  155.       RXClass lineDesc = (RXClass)classDict.At("AcDbLine");
  156.       IPropertyManager2 pPropMan =
  157.         (IPropertyManager2)xOPM.xGET_OPMPROPERTY_MANAGER(lineDesc);
  159.       pPropMan.RemoveProperty((object)custProp);
  160.       custProp = null;
  161.     }
  162.   }
  163.   #endregion
  164. }
A few comments on what this code does…
It defines a class for our custom dynamic property (CustomProp), for which we need a unique GUID (and yes, by definition GUIDs are unique, but if you use the same one twice it ceases to be :-), and implement various callbacks to indicate the name, type, description and writeability of the property, as well as methods to get and set the property value. For this example our property is called “My integer property”, and – guess what? – it’s an integer, and has been hardcoded to have the value 4. We’re not actually storing the data being exposed via this property, but in a real-world application you would probably store it either as XData attached to the object, inside an XRecord in the object’s extension dictionary or in an external database of some kind.
In the rest of the code we’re defining functions that are called when the module is loaded and when AutoCAD terminates (see this previous post for more information on this mechanism). We use the Initialize() callback to load our mixed-mode module for which we presented the code in the last post (asdkOPMNetExt.dll) and then go ahead and instantiate our property and attach it to line objects.
When we build and load the sample, making sure the Properties Palette is visible (using the PROPS command or by double-clicking on the line) and selecting a line we’ve just drawn, we should see our dynamic property appear, as shown in this image.
If you don’t see the property appear, the application is probably having trouble loading asdkOPMNetExt.dll: as mentioned earlier I have placed both this and the sample application in the root folder of my AutoCAD installation. If you’re not sure whether the module is loaded properly, you can step through the Initialize() function in the debugger or add a simple command to your code which will obviously only work if your application has been loaded (the Assembly.LoadFrom() call will throw an exception if it doesn’t find the module, and if an exception is thrown from Initialize() the application will not be loaded, as described in this previous post).
For the sake of simplicity I’m going to leave this basic sample as having just one, hardwired property: hopefully it’s obvious how the application could be extended to handle more properties and to store these properties with their objects (if not, let me know by posting a comment and I’ll put together a more extensive example when I get the chance).

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

x
回复 支持 反对

使用道具 举报

雪山飞狐_lzh
 楼主| 发表于 2009-8-18 11:30 | 显示全部楼层

Kean专题(14)—Dynamic_Blocks

一、访问动态块属性
March 04, 2009
Accessing the properties of a dynamic AutoCAD block using .NET
This is one of those funny scenarios... I was just thinking about what to do for my next post - whether to dive into some new features of AutoCAD 2010 (which I will do soon, I promise! :-) or whether to choose something from my ever-increasing to-do list, when I received two emails.
One was from our old friend Fernando Malard, suggesting a topic for a blog post, and the other was from Philippe Leefsma, a member of our DevTech team in Europe, in response to an ADN members question. It provided some code that could eventually form the basis for a response to Fernando's question. Coincidence? Maybe. Am I one to ignore serendipity at work (or to look a gift horse in the mouth)? No!
So, here's Fernando's question:
    Just would suggest a new topic for your Blog. An article explaining how to insert a dynamic block and modifying its dynamic properties like point, rotation, dimension. This is something I’m currently working on .NET and I think it would be a very interesting topic to evolve.
Philippe's code is a little different - it shows how to retrieve and display the "dynamic" properties of a dynamic block read in from an external file - but it was a great start for my first step towards Fernando's goal, which was simply to access the dynamic properties for a block selected by the user.
Here's the C# code I based on Philippe's:
  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 DynamicBlocks
  9. {
  10.   public class Commands
  11.   {
  12.     [CommandMethod("DBP")]
  13.     static public void DynamicBlockProps()
  14.     {
  15.       Document doc =
  16.         Application.DocumentManager.MdiActiveDocument;
  17.       Database db = doc.Database;
  18.       Editor ed = doc.Editor;
  20.       PromptStringOptions pso =
  21.         new PromptStringOptions(
  22.           "\nEnter dynamic block name or enter to select: "
  23.         );
  25.       pso.AllowSpaces = true;
  26.       PromptResult pr = ed.GetString(pso);
  28.       if (pr.Status != PromptStatus.OK)
  29.         return;
  31.       Transaction tr =
  32.         db.TransactionManager.StartTransaction();
  33.       using (tr)
  34.       {
  35.         BlockReference br = null;
  37.         // If a null string was entered allow entity selection
  39.         if (pr.StringResult == "")
  40.         {
  41.           // Select a block reference
  43.           PromptEntityOptions peo =
  44.             new PromptEntityOptions(
  45.               "\nSelect dynamic block reference: "
  46.             );
  48.           peo.SetRejectMessage("\nEntity is not a block.");
  49.           peo.AddAllowedClass(typeof(BlockReference), false);
  51.           PromptEntityResult per =
  52.             ed.GetEntity(peo);
  54.           if (per.Status != PromptStatus.OK)
  55.             return;
  57.           // Access the selected block reference
  59.           br =
  60.             tr.GetObject(
  61.               per.ObjectId,
  62.               OpenMode.ForRead
  63.             ) as BlockReference;
  64.         }
  65.         else
  66.         {
  67.           // Otherwise we look up the block by name
  69.           BlockTable bt =
  70.             tr.GetObject(
  71.               db.BlockTableId,
  72.               OpenMode.ForRead) as BlockTable;
  74.           if (!bt.Has(pr.StringResult))
  75.           {
  76.             ed.WriteMessage(
  77.               "\nBlock "" + pr.StringResult + "" does not exist."
  78.             );
  79.             return;
  80.           }
  82.           // Create a new block reference referring to the block
  84.           br =
  85.             new BlockReference(
  86.               new Point3d(),
  87.               bt[pr.StringResult]
  88.             );
  89.         }
  91.         BlockTableRecord btr =
  92.           (BlockTableRecord)tr.GetObject(
  93.             br.DynamicBlockTableRecord,
  94.             OpenMode.ForRead
  95.           );
  97.         // Call our function to display the block properties
  99.         DisplayDynBlockProperties(ed, br, btr.Name);
  101.         // Committing is cheaper than aborting
  103.         tr.Commit();
  104.       }
  105.     }
  107.     private static void DisplayDynBlockProperties(
  108.       Editor ed, BlockReference br, string name
  109.     )
  110.     {
  111.       // Only continue is we have a valid dynamic block
  113.       if (br != null && br.IsDynamicBlock)
  114.       {
  115.         ed.WriteMessage(
  116.           "\nDynamic properties for "{0}"\n",
  117.           name
  118.         );
  120.         // Get the dynamic block's property collection
  122.         DynamicBlockReferencePropertyCollection pc =
  123.           br.DynamicBlockReferencePropertyCollection;
  125.         // Loop through, getting the info for each property
  127.         foreach (DynamicBlockReferenceProperty prop in pc)
  128.         {
  129.           // Start with the property name, type and description
  131.           ed.WriteMessage(
  132.             "\nProperty: "{0}" : {1}",
  133.             prop.PropertyName,
  134.             prop.UnitsType
  135.           );
  137.           if (prop.Description != "")
  138.             ed.WriteMessage(
  139.               "\n  Description: {0}",
  140.               prop.Description
  141.             );
  143.           // Is it read-only?
  145.           if (prop.ReadOnly)
  146.             ed.WriteMessage(" (Read Only)");
  148.           // Get the allowed values, if it's constrained
  150.           bool first = true;
  152.           foreach (object value in prop.GetAllowedValues())
  153.           {
  154.             ed.WriteMessage(
  155.               (first ? "\n  Allowed values: [" : ", ")
  156.             );
  157.             ed.WriteMessage(""{0}"", value);
  159.             first = false;
  160.           }
  161.           if (!first)
  162.             ed.WriteMessage("]");
  164.           // And finally the current value
  166.           ed.WriteMessage(
  167.             "\n  Current value: "{0}"\n",
  168.             prop.Value
  169.           );
  170.         }
  171.       }
  172.     }
  173.   }
  174. }
Here's what happens when we run the DBP command, selecting the "Hex Socket Bolt (Side) - Metric" block from the "Mechanical - Metric.dwg" file in the Samples\Dynamic Blocks folder of your AutoCAD installation.
  1. Command: DBP
  2. Enter dynamic block name or enter to select:
  3. Select dynamic block reference:
  5. Dynamic properties for "Hex Socket Bolt (Side) - Metric"
  7. Property: "d1" : Distance
  8.   Allowed values: ["3", "4", "5", "6", "8", "10", "12", "14", "16", "20", "24",
  9. "27", "30", "36"]
  10.   Current value: "14"
  12. Property: "Origin" : NoUnits (Read Only)
  13.   Current value: "(97.714,-5,0)"
  15. Property: "b" : Distance
  16.   Allowed values: ["18", "20", "22", "24", "28", "32", "36", "40", "44", "52",
  17. "57", "60", "65", "66", "72", "73", "84", "85"]
  18.   Current value: "40"
  20. Property: "Origin" : NoUnits (Read Only)
  21.   Current value: "(100,-3.5,0)"
  23. Property: "k" : Distance
  24.   Allowed values: ["3", "4", "5", "6", "8", "10", "12", "14", "16", "20", "24",
  25. "27", "30", "36"]
  26.   Current value: "14"
  28. Property: "Origin" : NoUnits (Read Only)
  29.   Current value: "(5.64204767561892E-15,-7,0)"
  31. Property: "d2" : Distance
  32.   Allowed values: ["5.5", "7", "8.5", "10", "13", "16", "18", "21", "24", "30",
  33. "36", "40", "45", "54"]
  34.   Current value: "21"
  36. Property: "Origin" : NoUnits (Read Only)
  37.   Current value: "(3.5527136788005E-15,-8,0)"
  39. Property: "Size" : NoUnits
  40.   Allowed values: ["M3", "M4", "M5", "M6", "M8", "M10", "M12", "M14"]
  41.   Current value: "M14"
  43. Property: "Visibility" : NoUnits
  44.   Allowed values: ["M3", "M4", "M5", "M6", "M8", "M10", "M12", "M14"]
  45.   Current value: "M14"
  47. Property: "Length (M3)" : Distance
  48.   Description: Set the bolt length
  49.   Allowed values: ["25", "30", "35", "40", "45", "50", "60"]
  50.   Current value: "100"
  52. Property: "Origin" : NoUnits (Read Only)
  53.   Current value: "(0,0,0)"
  55. Property: "Length (M4)" : Distance
  56.   Description: Set the bolt length
  57.   Allowed values: ["30", "35", "40", "45", "50", "60", "70", "80"]
  58.   Current value: "100"
  60. Property: "Origin" : NoUnits (Read Only)
  61.   Current value: "(0,0,0)"
  63. Property: "Length (M5)" : Distance
  64.   Description: Set the bolt length
  65.   Allowed values: ["30", "35", "40", "45", "50", "55", "60", "70", "80", "90",
  66. "100"]
  67.   Current value: "100"
  69. Property: "Origin" : NoUnits (Read Only)
  70.   Current value: "(0,0,0)"
  72. Property: "Length (M6)" : Distance
  73.   Description: Set the bolt length
  74.   Allowed values: ["35", "40", "45", "50", "55", "60", "65", "70", "75", "80",
  75. "90", "100", "110", "120"]
  76.   Current value: "100"
  78. Property: "Origin" : NoUnits (Read Only)
  79.   Current value: "(2.25597318603832E-14,0,0)"
  81. Property: "Length (M8)" : Distance
  82.   Description: Set the bolt length
  83.   Allowed values: ["40", "45", "50", "55", "60", "65", "70", "75", "80", "85",
  84. "90", "100", "110", "120", "130", "140", "150", "160", "180", "200"]
  85.   Current value: "100"
  87. Property: "Origin" : NoUnits (Read Only)
  88.   Current value: "(2.25597318603832E-14,0,0)"
  90. Property: "Length (M10)" : Distance
  91.   Description: Set the bolt length
  92.   Allowed values: ["45", "50", "55", "60", "65", "70", "75", "80", "85", "90",
  93. "100", "110", "120", "130", "140", "150", "160", "180", "200"]
  94.   Current value: "100"
  96. Property: "Origin" : NoUnits (Read Only)
  97.   Current value: "(2.25597318603832E-14,0,0)"
  99. Property: "Length (M12)" : Distance
  100.   Description: Set the bolt length
  101.   Allowed values: ["55", "60", "65", "70", "75", "80", "85", "90", "100",
  102. "110", "120", "130", "140", "150", "160", "180", "200"]
  103.   Current value: "100"
  105. Property: "Origin" : NoUnits (Read Only)
  106.   Current value: "(2.25597318603832E-14,0,0)"
  108. Property: "Length (M14)" : Distance
  109.   Description: Set the bolt length
  110.   Allowed values: ["60", "65", "70", "75", "80", "90", "100", "110", "120",
  111. "130", "140", "150", "160"]
  112.   Current value: "100"
  114. Property: "Origin" : NoUnits (Read Only)
  115.   Current value: "(2.25597318603832E-14,0,0)"
复制代码
Many of the properties are actually 0, but have ended up being printed as a very small number... it would be simple enough to check these against a tolerance rather than trusting them to be understood as being zero.
OK, that's a good enough start for today. In the next post we'll address the need to capture dynamic properties from an inserted dynamic block and copy them across to another, already-inserted dynamic block. A bit like a "property painter" for dynamic blocks. (If you're thinking that this doesn't sound quite like what Fernando originally asked for, then you'd be quite right. We exchanged a few emails, and I then opted for a "property painter" approach to address the problem.)
Thanks for the inspiration, Fernando and Philippe! :-)

回复 支持 反对

使用道具 举报

123下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

小黑屋|手机版|CAD论坛|CAD教程|CAD下载|联系我们|关于明经|明经通道 ( 粤ICP备05003914号 )  
©2000-2023 明经通道 版权所有 本站代码，在未取得本站及作者授权的情况下，不得用于商业用途

GMT+8, 2024-4-20 11:10 , Processed in 4.620935 second(s), 17 queries , Gzip On.

Powered by Discuz! X3.4

Copyright © 2001-2021, Tencent Cloud.

快速回复 返回顶部 返回列表