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

明经CAD社区

 找回密码
 注册

QQ登录

只需一步，快速开始

搜索
明经CAD社区»社区 › 开发篇 › AutoCAD.net/VB.net/C# 编程技术 › Kean专题(11)—Overrules
12下一页
返回列表 发新帖
查看: 11612|回复: 10

[Kean专集] Kean专题(11)—Overrules

   关闭 [复制链接]
雪山飞狐_lzh
发表于 2009-6-15 18:20 | 显示全部楼层 |阅读模式
原帖：http://through-the-interface.typepad.com/through_the_interface/overrules/
一、使用F#自定义实体的显示
March 27, 2009
Customizing the display of standard AutoCAD objects using F#
This post is one of the winning entries of the F# programming contest started at the beginning of the year. It was submitted by an old friend of mine, Qun Lu, who also happens to be a member of the AutoCAD engineering team, and makes use of a new API in AutoCAD 2010: the somewhat ominously-named Overrule API.
The Overrule API is really (and I mean really, really) cool. Yes, I know: another really cool API in AutoCAD 2010? Well, I’m honestly not one to hype things up, but I do have a tendency to get excited by technology that has incredibly interesting capabilities with a relatively low barrier of entry. And the Overrule API is one of those APIs. It’s the answer to the question posed in this previous post, which raises concerns about translating the power and complexity of custom objects to the world of .NET:
So what’s the right thing to do? Clearly we could just go ahead and expose the mechanism as it is today in ObjectARX. And yet here we are with a technology we know to be highly complex and difficult to implement, and an ideal opportunity to redesign it – enabling more people to harness it effectively at lower effort. The more favoured approach (at least from our perspective) would be to investigate further how better to meet developers’ needs for enabling custom graphics/behaviour (a.k.a. stylization) in AutoCAD – in a way that could be supported technically for many releases to come.
The Overrule API allows you to hook into the display and other aspects of the behaviour of entities inside AutoCAD. The below example is a great example: when enabled, the code overrules the display of lines and circles, to make them into coloured pipes. And all with very little code (which would also be true if the code were in C# or VB.NET).
Here’s the F# code:
  2. #light
  3. module DrawOverrule.Commands
  4. open Autodesk.AutoCAD.Runtime
  5. open Autodesk.AutoCAD.ApplicationServices
  6. open Autodesk.AutoCAD.DatabaseServices
  7. open Autodesk.AutoCAD.Geometry
  8. open Autodesk.AutoCAD.GraphicsInterface
  9. open Autodesk.AutoCAD.Colors
  11. type public DrawOverrule public () as this =
  12.   inherit DrawableOverrule()
  14.   static member public theOverrule =
  15.     new DrawOverrule()
  17.   static member private Radius = 0.5
  19.   member private this.sweepOpts = new SweepOptions()
  21.   override this.WorldDraw (d : Drawable, wd : WorldDraw) =
  22.     match d with
  23.       // Type-test and cast. If succeeds, cast to "line"
  24.       | :? Line as line ->
  25.         // Draw the line as is, with overruled attributes
  26.         base.WorldDraw(line, wd) |> ignore
  27.         if not line.Id.IsNull && line.Length > 0.0 then
  28.           // Draw a pipe around the line
  29.           let c = wd.SubEntityTraits.TrueColor
  30.           wd.SubEntityTraits.TrueColor <-
  31.             new EntityColor(0x00AfAfff)
  32.           wd.SubEntityTraits.LineWeight <-
  33.             LineWeight.LineWeight000
  34.           let clr =
  35.             new Circle
  36.               (line.StartPoint, line.EndPoint-line.StartPoint,
  37.               DrawOverrule.Radius)
  38.           let pipe = new ExtrudedSurface()
  39.           try
  40.             pipe.CreateExtrudedSurface
  41.               (clr, line.EndPoint-line.StartPoint, this.sweepOpts)
  42.           with
  43.             | e -> printfn("Failed with CreateExtrudedSurface")
  44.           clr.Dispose()
  45.           pipe.WorldDraw(wd) |> ignore
  46.           pipe.Dispose()
  47.           wd.SubEntityTraits.TrueColor <- c
  48.         true
  49.       | :? Circle as circle ->
  50.         // Draw the circle as is, with overruled attributes
  51.         base.WorldDraw(circle, wd) |> ignore
  53.         // needed to avoid ill-formed swept surface
  54.         if circle.Radius > DrawOverrule.Radius then
  55.           // draw a pipe around the cirle
  56.           let c = wd.SubEntityTraits.TrueColor
  57.           wd.SubEntityTraits.TrueColor <-
  58.             new EntityColor(0x3fffe0e0)
  59.           wd.SubEntityTraits.LineWeight <-
  60.             LineWeight.LineWeight000
  61.           let normal =
  62.             (circle.Center-circle.StartPoint).
  63.               CrossProduct(circle.Normal)
  64.           let clr =
  65.             new Circle
  66.               (circle.StartPoint, normal, DrawOverrule.Radius)
  67.           let pipe = new SweptSurface()
  68.           pipe.CreateSweptSurface(clr, circle, this.sweepOpts)
  69.           clr.Dispose()
  70.           pipe.WorldDraw(wd) |> ignore
  71.           pipe.Dispose()
  72.           wd.SubEntityTraits.TrueColor <- c
  73.         true
  74.       | _ ->
  75.         base.WorldDraw(d, wd)
  77.   override this.SetAttributes (d : Drawable, t : DrawableTraits) =
  78.     let b = base.SetAttributes(d, t)
  79.     match d with
  80.       | :? Line ->
  81.         // If d is LINE, set color to index 6
  82.         t.Color <- 6s
  83.         // and lineweight to .40 mm
  84.         t.LineWeight <- LineWeight.LineWeight040
  85.       | :? Circle ->   
  86.         // If d is CIRCLE, set color to index 2
  87.         t.Color <- 2s
  88.         // and lineweight to .60 mm
  89.         t.LineWeight <- LineWeight.LineWeight060
  90.       | _ -> ()
  91.     b
  93. let Overrule enable =
  94.   // Regen to see the effect
  95.   // (turn on/off Overruling and LWDISPLAY)
  96.   DrawableOverrule.Overruling <- enable
  97.   match enable with
  98.     | true -> Application.SetSystemVariable("LWDISPLAY", 1)
  99.     | false -> Application.SetSystemVariable("LWDISPLAY", 0)
  100.   let doc =
  101.     Application.DocumentManager.MdiActiveDocument
  102.   doc.SendStringToExecute("REGEN3\n", true, false, false)
  103.   doc.Editor.Regen()
  105. // Now we declare our commands
  107. [<CommandMethod("overrule1")>]
  108. let OverruleStart() =
  109.   // Targeting all Drawables, but only affects Lines and Circles
  110.   ObjectOverrule.AddOverrule
  111.     (RXClass.GetClass(typeof<Drawable>),
  112.     DrawOverrule.theOverrule, true)
  113.   Overrule(true)
  115. [<CommandMethod("overrule0")>]
  116. let OverruleEnd() =
  117.   Overrule(false)
Here’s what happens when we load the application, turn the overrule on using the OVERRULE1 command (OVERRULE0 is the command to turn the overrule off – it’s details like this that tell you Qun’s a real programmer… ;-) and draw some lines and circles:

Even in a 3D view – this time with the realistic visual style applied – you get the piping effect when you draw simple geometry:
To be clear: these are standard AutoCAD lines and circles. When you use the OVERRULE0 command to disable the overrule, they revert to their original form:

I expect to follow this post – in time – with various more harnessing the power of this very cool API. If you have questions or ideas about how it might be used, be sure to post a comment.
Thanks & congratulations, Qun! Your copy of “Expert F#” is on its way to you via inter-office mail. :-) More soon on the other winning entry…

本帖子中包含更多资源

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

x
回复

使用道具 举报

雪山飞狐_lzh
 楼主| 发表于 2009-6-15 18:28 | 显示全部楼层
C#版本
April 08, 2009
Customizing the display of standard AutoCAD objects using .NET
The code in this post is a direct port of the F# code in this previous post, which was entered by Qun Lu in the recent F# programming contest. Someone – very validly - commented on the fact the post involved both a new language and a new API, which was probably pushing things a little from a learning perspective. :-)
Without repeating my various comments in the previous post, I will reiterate the fact that this API is extremely interesting for developers who wish to customize the appearance and behaviour of standard AutoCAD objects without going through the pain of implementing full custom objects.
Here’s the equivalent C# code that works with AutoCAD 2010:
  2. using Autodesk.AutoCAD.ApplicationServices;
  3. using Autodesk.AutoCAD.Runtime;
  4. using Autodesk.AutoCAD.DatabaseServices;
  5. using Autodesk.AutoCAD.Geometry;
  6. using Autodesk.AutoCAD.GraphicsInterface;
  7. using Autodesk.AutoCAD.Colors;
  9. namespace DrawOverrule
  10. {
  11.   public class DrawOverrule : DrawableOverrule
  12.   {
  13.     static public DrawOverrule theOverrule =
  14.       new DrawOverrule();
  16.     static private double Radius = 0.5;
  18.     private SweepOptions sweepOpts = new SweepOptions();
  20.     public override bool WorldDraw (Drawable d, WorldDraw wd)
  21.     {
  22.       if (d is Line)
  23.       {
  24.         Line line = (Line)d;
  26.         // Draw the line as is, with overruled attributes
  28.         base.WorldDraw(line, wd);
  29.         if (!line.Id.IsNull && line.Length > 0.0)
  30.         {
  31.           // Draw a pipe around the line
  33.           EntityColor c =
  34.             wd.SubEntityTraits.TrueColor;
  35.           wd.SubEntityTraits.TrueColor =
  36.             new EntityColor(0x00AfAfff);
  37.           wd.SubEntityTraits.LineWeight =
  38.             LineWeight.LineWeight000;
  39.           Circle clr =
  40.             new Circle(
  41.               line.StartPoint,
  42.               line.EndPoint - line.StartPoint,
  43.               DrawOverrule.Radius
  44.             );
  45.           ExtrudedSurface pipe = new ExtrudedSurface();
  46.           try
  47.           {
  48.             pipe.CreateExtrudedSurface(
  49.               clr, line.EndPoint-line.StartPoint, sweepOpts
  50.             );
  51.           }
  52.           catch
  53.           {
  54.             Document doc =
  55.               Application.DocumentManager.MdiActiveDocument;
  56.             doc.Editor.WriteMessage(
  57.               "\nFailed with CreateExtrudedSurface."
  58.             );
  59.           }
  60.           clr.Dispose();
  61.           pipe.WorldDraw(wd);
  62.           pipe.Dispose();
  63.           wd.SubEntityTraits.TrueColor = c;
  64.         }
  65.         return true;
  66.       }
  67.       else if (d is Circle)
  68.       {
  69.         Circle circle = (Circle)d;
  71.         // Draw the circle as is, with overruled attributes
  73.         base.WorldDraw(circle, wd);
  75.         // Needed to avoid ill-formed swept surface
  77.         if (circle.Radius > DrawOverrule.Radius)
  78.         {
  79.           // Draw a pipe around the cirle
  81.           EntityColor c = wd.SubEntityTraits.TrueColor;
  82.           wd.SubEntityTraits.TrueColor =
  83.             new EntityColor(0x3fffe0e0);
  84.           wd.SubEntityTraits.LineWeight =
  85.             LineWeight.LineWeight000;
  86.           Vector3d normal =
  87.             (circle.Center-circle.StartPoint).
  88.               CrossProduct(circle.Normal);
  89.           Circle clr =
  90.             new Circle(
  91.               circle.StartPoint, normal, DrawOverrule.Radius
  92.             );
  93.           SweptSurface pipe = new SweptSurface();
  94.           pipe.CreateSweptSurface(clr, circle, sweepOpts);
  95.           clr.Dispose();
  96.           pipe.WorldDraw(wd);
  97.           pipe.Dispose();
  98.           wd.SubEntityTraits.TrueColor = c;
  99.         }
  100.         return true;
  101.       }
  102.       return base.WorldDraw(d, wd);
  103.     }
  105.     public override int SetAttributes (Drawable d, DrawableTraits t)
  106.     {
  107.       int b = base.SetAttributes(d, t);
  108.       if (d is Line)
  109.       {
  110.         // If d is LINE, set color to index 6
  112.         t.Color = 6;
  114.         // and lineweight to .40 mm
  116.         t.LineWeight = LineWeight.LineWeight040;
  117.       }
  118.       else if (d is Circle)
  119.       {
  120.         // If d is CIRCLE, set color to index 2
  122.         t.Color = 2;
  124.         // and lineweight to .60 mm
  126.         t.LineWeight = LineWeight.LineWeight060;
  127.       }
  128.       return b;
  129.     }
  130.   }
  132.   public class Commands
  133.   {
  134.     public void Overrule(bool enable)
  135.     {
  136.       // Regen to see the effect
  137.       // (turn on/off Overruling and LWDISPLAY)
  139.       DrawableOverrule.Overruling = enable;
  140.       if (enable)
  141.         Application.SetSystemVariable("LWDISPLAY", 1);
  142.       else
  143.         Application.SetSystemVariable("LWDISPLAY", 0);
  145.       Document doc =
  146.         Application.DocumentManager.MdiActiveDocument;
  147.       doc.SendStringToExecute("REGEN3\n", true, false, false);
  148.       doc.Editor.Regen();
  149.     }
  151.     [CommandMethod("OVERRULE1")]
  152.     public void OverruleStart()
  153.     {
  154.       ObjectOverrule.AddOverrule
  155.         (RXClass.GetClass(typeof(Drawable)),
  156.         DrawOverrule.theOverrule, true);
  157.       Overrule(true);
  158.     }
  160.     [CommandMethod("OVERRULE0")]
  161.     public void OverruleEnd()
  162.     {
  163.       Overrule(false);
  164.     }
  165.   }
  166. }
回复 支持 反对

使用道具 举报

雪山飞狐_lzh
 楼主| 发表于 2009-6-16 08:44 | 显示全部楼层
二、图元炸开重定义
April 16, 2009
Overruling explode in AutoCAD 2010 using .NET
I am really starting to love the new Overrule API in AutoCAD 2010, and I still feel as though I’m just scratching the surface. This question came in overnight from Danny Polkinhorn (thanks, Danny! :-) :
It's exciting to see a very usable implementation of 'custom' objects in .NET. Obviously, this implementation protects what could be proprietary business intelligence from being sent around, but it brings up a question. What process would you use to 'explode' these elements so that you could send the drawing to someone without your code, but with the custom elements in it?
My first thought was to just see what happened when the EXPLODE command encountered the overruled lines & circles created with the code in the last post. At first I was a little discouraged:
  1. Command: EXPLODE
  2. Select objects: Specify opposite corner: 9 found
  3. 9 were not able to be exploded.
  4. Select objects: *Cancel*
  5. None found.
复制代码
My worry, at this stage, was that the EXPLODE command was excluding “simple” objects such as lines and circles during its selection process, which would mean that even if we were able to overrule the explode behaviour of our special lines & circles we would have difficulty getting our code called. Thankfully this is not the case, but I only found this out as I implemented a TransformOverrule and overruled Explode for my lines and circles.
Before looking into the specifics, here’s a quick list of the various Overrules available in AutoCAD 2010 with their overrideable methods:
Overrule (the base class)
  2. GripOverrule
  3.       GetGripPoints
  4.       GetStretchPoints
  5.       MoveGripPointsAt
  6.       MoveStretchPointsAt
  7.       OnGripStatusChanged
  8.       OsnapOverrule
  9.       GetObjectSnapPoints
  10.       IsContentSnappable
  11. SubentityOverrule
  12.       AddSubentPaths
  13.       DeleteSubentPaths
  14.       GetCompoundObjectTransform
  15.       GetGripPointsAtSubentPath
  16.       GetGsMarkersAtSubentPath
  17.       GetSubentClassId
  18.       GetSubentPathGeomExtents
  19.       GetSubentPathsAtGsMarker
  20.       MoveGripPointsAtSubentPaths
  21.       OnSubentGripStatusChanged
  22.       SubentPtr
  23.       TransformSubentPathsBy
  24. TransformOverrule
  25.       CloneMeForDragging
  26.       Explode
  27.       GetTransformedCopy
  28.       HideMeForDragging
  29.       TransformBy
  30. GeometryOverrule
  31.       GetGeomExtents
  32.       IntersectWith
  33. PropertiesOverrule
  34.       GetClassID
  35.       List
  36. ObjectOverrule
  37.       Cancel
  38.       Close
  39.       DeepClone
  40.       Erase
  41.       Open
  42.       WblockClone
  43. DrawableOverrule
  44.       SetAttributes
  45.       ViewportDraw
  46.       ViewportDrawLogicalFlags
  47.       WorldDraw
So far we’ve only actually used the DrawableOverrule, implementing SetAttributes() and WorldDraw().
[Aside: as I compiled the above list I had one of those “woah” moments. It was bit like the feeling I remember as a child while reading “ The Elfstones of Shannara”, the – much better – sequel to “ The Sword of Shannara” ( Terry Brooks’ first  fantasy novel). In “The Sword of Shannara” the main character used some  elfstones for protection, but it’s only in the sequel that you find out just how powerful they are, and that they’re actually only one of several different varieties of elfstones. Anyone who hasn’t been a fantasy/sci-fi geek in their time is almost certainly rolling their eyes (if they’re not being physically sick) at this point, so I’d better get back on track. I still enjoy a good sci-fi novel, by the way, but these days I find I can’t do fantasy that isn’t  Tolkien.]
It’s clear that to customize the explode for our lines and circles we’re going to need a TransformOverrule.
Here’s the C# code from the last post, with our additional TransformOverrules. I’ve changed a few of the class names to reflect the fact they are overrule draw behaviour vs. transform behaviour, but otherwise the code is basically the same as last time, apart from the addition of the LinePipeTransformOverrule and CirclePipeTransformOverrule classes (and the code to register/unregister them).
The Explode functions take pretty much the same geometry we used to draw the “enhanced” objects, but this time it gets returned to the system and is used to replace the original entities. This code doesn’t do anything fancy about the entity colour, etc., but we could certainly do so, if we chose.
  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;
  7. using Autodesk.AutoCAD.GraphicsInterface;
  8. using Autodesk.AutoCAD.Colors;
  10. namespace Overrules
  11. {
  12.   public abstract class PipeDrawOverrule : DrawableOverrule
  13.   {
  14.     const string regAppName = "TTIF_PIPE";
  16.     public PipeDrawOverrule()
  17.     {
  18.       // Tell AutoCAD to filter on our application name
  19.       // (this means our overrule will only be called
  20.       // on objects possessing XData with this name)
  22.       SetXDataFilter(regAppName);
  23.     }
  25.     // Get the XData for a particular object
  26.     // and return the "pipe radius" if it exists
  28.     public static double PipeRadiusForObject(DBObject obj)
  29.     {
  30.       double res = 0.0;
  32.       ResultBuffer rb = obj.XData;
  33.       if (rb != null)
  34.       {
  35.         bool foundStart = false;
  37.         foreach (TypedValue tv in rb)
  38.         {
  39.           if (tv.TypeCode == (int)DxfCode.ExtendedDataRegAppName &&
  40.               tv.Value.ToString() == regAppName)
  41.             foundStart = true;
  42.           else
  43.           {
  44.             if (foundStart == true)
  45.             {
  46.               if (tv.TypeCode == (int)DxfCode.ExtendedDataReal)
  47.               {
  48.                 res = (double)tv.Value;
  49.                 break;
  50.               }
  51.             }
  52.           }
  53.         }
  54.         rb.Dispose();
  55.       }
  56.       return res;
  57.     }
  59.     // Set the "pipe radius" in the XData of a particular object
  61.     public static void SetPipeRadiusOnObject(
  62.       Transaction tr, DBObject obj, double radius
  63.     )
  64.     {
  65.       Database db = obj.Database;
  67.       // Make sure the application is registered
  68.       // (we could separate this out to be called
  69.       // only once for a set of operations)
  71.       RegAppTable rat =
  72.         (RegAppTable)tr.GetObject(
  73.           db.RegAppTableId,
  74.           OpenMode.ForRead
  75.         );
  77.       if (!rat.Has(regAppName))
  78.       {
  79.         rat.UpgradeOpen();
  80.         RegAppTableRecord ratr = new RegAppTableRecord();
  81.         ratr.Name = regAppName;
  82.         rat.Add(ratr);
  83.         tr.AddNewlyCreatedDBObject(ratr, true);
  84.       }
  86.       // Create the XData and set it on the object
  88.       ResultBuffer rb =
  89.         new ResultBuffer(
  90.           new TypedValue(
  91.             (int)DxfCode.ExtendedDataRegAppName, regAppName
  92.           ),
  93.           new TypedValue(
  94.             (int)DxfCode.ExtendedDataReal, radius
  95.           )
  96.         );
  97.       obj.XData = rb;
  98.       rb.Dispose();
  99.     }
  100.   }
  102.   // An overrule to make a pipe out of line
  104.   public class LinePipeDrawOverrule : PipeDrawOverrule
  105.   {
  106.     static public LinePipeDrawOverrule theOverrule =
  107.       new LinePipeDrawOverrule();
  109.     private SweepOptions sweepOpts = new SweepOptions();
  111.     public override bool WorldDraw(Drawable d, WorldDraw wd)
  112.     {
  113.       double radius = 0.0;
  115.       if (d is DBObject)
  116.         radius = PipeRadiusForObject((DBObject)d);
  118.       if (radius > 0.0)
  119.       {
  120.         Line line = d as Line;
  122.         if (line != null)
  123.         {
  124.           // Draw the line as is, with overruled attributes
  126.           base.WorldDraw(line, wd);
  127.           if (!line.Id.IsNull && line.Length > 0.0)
  128.           {
  129.             // Draw a pipe around the line
  131.             EntityColor c =
  132.               wd.SubEntityTraits.TrueColor;
  133.             wd.SubEntityTraits.TrueColor =
  134.               new EntityColor(0x00AfAfff);
  135.             wd.SubEntityTraits.LineWeight =
  136.               LineWeight.LineWeight000;
  137.             Circle clr =
  138.               new Circle(
  139.                 line.StartPoint,
  140.                 line.EndPoint - line.StartPoint,
  141.                 radius
  142.               );
  143.             ExtrudedSurface pipe = new ExtrudedSurface();
  144.             try
  145.             {
  146.               pipe.CreateExtrudedSurface(
  147.                 clr, line.EndPoint - line.StartPoint, sweepOpts
  148.               );
  149.             }
  150.             catch
  151.             {
  152.               Document doc =
  153.                 Application.DocumentManager.MdiActiveDocument;
  154.               doc.Editor.WriteMessage(
  155.                 "\nFailed with CreateExtrudedSurface."
  156.               );
  157.             }
  158.             clr.Dispose();
  159.             pipe.WorldDraw(wd);
  160.             pipe.Dispose();
  161.             wd.SubEntityTraits.TrueColor = c;
  162.           }
  163.           return true;
  164.         }
  165.       }
  166.       return base.WorldDraw(d, wd);
  167.     }
  169.     public override int SetAttributes(Drawable d, DrawableTraits t)
  170.     {
  171.       int b = base.SetAttributes(d, t);
  173.       double radius = 0.0;
  175.       if (d is DBObject)
  176.         radius = PipeRadiusForObject((DBObject)d);
  178.       if (radius > 0.0)
  179.       {
  180.         // Set color to index 6
  182.         t.Color = 6;
  184.         // and lineweight to .40 mm
  186.         t.LineWeight = LineWeight.LineWeight040;
  187.       }
  188.       return b;
  189.     }
  190.   }
  192.   // An overrule to make a pipe out of circle
  194.   public class CirclePipeDrawOverrule : PipeDrawOverrule
  195.   {
  196.     static public CirclePipeDrawOverrule theOverrule =
  197.       new CirclePipeDrawOverrule();
  199.     private SweepOptions sweepOpts = new SweepOptions();
  201.     public override bool WorldDraw(Drawable d, WorldDraw wd)
  202.     {
  203.       double radius = 0.0;
  205.       if (d is DBObject)
  206.         radius = PipeRadiusForObject((DBObject)d);
  208.       if (radius > 0.0)
  209.       {
  210.         Circle circle = d as Circle;
  212.         if (circle != null)
  213.         {
  214.           // Draw the circle as is, with overruled attributes
  216.           base.WorldDraw(circle, wd);
  218.           // Needed to avoid ill-formed swept surface
  220.           if (circle.Radius > radius)
  221.           {
  222.             // Draw a pipe around the cirle
  224.             EntityColor c = wd.SubEntityTraits.TrueColor;
  225.             wd.SubEntityTraits.TrueColor =
  226.               new EntityColor(0x3fffe0e0);
  227.             wd.SubEntityTraits.LineWeight =
  228.               LineWeight.LineWeight000;
  229.             Vector3d normal =
  230.               (circle.Center - circle.StartPoint).
  231.                 CrossProduct(circle.Normal);
  232.             Circle clr =
  233.               new Circle(
  234.                 circle.StartPoint, normal, radius
  235.               );
  236.             SweptSurface pipe = new SweptSurface();
  237.             pipe.CreateSweptSurface(clr, circle, sweepOpts);
  238.             clr.Dispose();
  239.             pipe.WorldDraw(wd);
  240.             pipe.Dispose();
  241.             wd.SubEntityTraits.TrueColor = c;
  242.           }
  243.           return true;
  244.         }
  245.       }
  246.       return base.WorldDraw(d, wd);
  247.     }
  249.     public override int SetAttributes(Drawable d, DrawableTraits t)
  250.     {
  251.       int b = base.SetAttributes(d, t);
  253.       double radius = 0.0;
  255.       if (d is DBObject)
  256.         radius = PipeRadiusForObject((DBObject)d);
  258.       if (radius > 0.0)
  259.       {
  260.         // Set color to index 2
  262.         t.Color = 2;
  264.         // and lineweight to .60 mm
  266.         t.LineWeight = LineWeight.LineWeight060;
  267.       }
  268.       return b;
  269.     }
  270.   }
  272.   public class LinePipeTransformOverrule : TransformOverrule
  273.   {
  274.     static public LinePipeTransformOverrule theOverrule =
  275.       new LinePipeTransformOverrule();
  277.     private SweepOptions sweepOpts = new SweepOptions();
  279.     public override void Explode(Entity e, DBObjectCollection objs)
  280.     {
  281.       double radius = 0.0;
  283.       if (e is DBObject)
  284.         radius = PipeDrawOverrule.PipeRadiusForObject(e);
  286.       if (radius > 0.0)
  287.       {
  288.         Line line = e as Line;
  290.         if (line != null)
  291.         {
  292.           if (!line.Id.IsNull && line.Length > 0.0)
  293.           {
  294.             // Draw a pipe around the line
  296.             Circle clr =
  297.               new Circle(
  298.                 line.StartPoint,
  299.                 line.EndPoint - line.StartPoint,
  300.                 radius
  301.               );
  302.             ExtrudedSurface pipe = new ExtrudedSurface();
  303.             try
  304.             {
  305.               pipe.CreateExtrudedSurface(
  306.                 clr, line.EndPoint - line.StartPoint, sweepOpts
  307.               );
  308.             }
  309.             catch
  310.             {
  311.               Document doc =
  312.                 Application.DocumentManager.MdiActiveDocument;
  313.               doc.Editor.WriteMessage(
  314.                 "\nFailed with CreateExtrudedSurface."
  315.               );
  316.             }
  317.             clr.Dispose();
  318.             objs.Add(pipe);
  319.           }
  320.           return;
  321.         }
  322.       }
  323.       base.Explode(e, objs);
  324.     }
  325.   }
  327.   public class CirclePipeTransformOverrule : TransformOverrule
  328.   {
  329.     static public CirclePipeTransformOverrule theOverrule =
  330.       new CirclePipeTransformOverrule();
  332.     private SweepOptions sweepOpts = new SweepOptions();
  334.     public override void Explode(Entity e, DBObjectCollection objs)
  335.     {
  336.       double radius = 0.0;
  338.       if (e is DBObject)
  339.         radius = PipeDrawOverrule.PipeRadiusForObject(e);
  341.       if (radius > 0.0)
  342.       {
  343.         Circle circle = e as Circle;
  345.         if (circle != null)
  346.         {
  347.           // Needed to avoid ill-formed swept surface
  349.           if (circle.Radius > radius)
  350.           {
  351.             // Draw a pipe around the cirle
  353.             Vector3d normal =
  354.               (circle.Center - circle.StartPoint).
  355.                 CrossProduct(circle.Normal);
  356.             Circle clr =
  357.               new Circle(
  358.                 circle.StartPoint, normal, radius
  359.               );
  360.             SweptSurface pipe = new SweptSurface();
  361.             pipe.CreateSweptSurface(clr, circle, sweepOpts);
  362.             clr.Dispose();
  363.             objs.Add(pipe);
  364.           }
  365.           return;
  366.         }
  367.       }
  368.       base.Explode(e, objs);
  369.     }
  370.   }
  372.   public class Commands
  373.   {
  374.     private double _radius = 0.0;
  376.     public void Overrule(bool enable)
  377.     {
  378.       // Regen to see the effect
  379.       // (turn on/off Overruling and LWDISPLAY)
  381.       DrawableOverrule.Overruling = enable;
  382.       if (enable)
  383.         Application.SetSystemVariable("LWDISPLAY", 1);
  384.       else
  385.         Application.SetSystemVariable("LWDISPLAY", 0);
  387.       Document doc =
  388.         Application.DocumentManager.MdiActiveDocument;
  389.       doc.SendStringToExecute("REGEN3\n", true, false, false);
  390.       doc.Editor.Regen();
  391.     }
  393.     [CommandMethod("OVERRULE1")]
  394.     public void OverruleStart()
  395.     {
  396.       ObjectOverrule.AddOverrule(
  397.         RXClass.GetClass(typeof(Line)),
  398.         LinePipeDrawOverrule.theOverrule,
  399.         true
  400.       );
  401.       ObjectOverrule.AddOverrule(
  402.         RXClass.GetClass(typeof(Circle)),
  403.         CirclePipeDrawOverrule.theOverrule,
  404.         true
  405.       );
  406.       ObjectOverrule.AddOverrule(
  407.         RXClass.GetClass(typeof(Line)),
  408.         LinePipeTransformOverrule.theOverrule,
  409.         true
  410.       );
  411.       ObjectOverrule.AddOverrule(
  412.         RXClass.GetClass(typeof(Circle)),
  413.         CirclePipeTransformOverrule.theOverrule,
  414.         true
  415.       );
  416.       Overrule(true);
  417.     }
  419.     [CommandMethod("OVERRULE0")]
  420.     public void OverruleEnd()
  421.     {
  422.       ObjectOverrule.RemoveOverrule(
  423.         RXClass.GetClass(typeof(Line)),
  424.         LinePipeDrawOverrule.theOverrule
  425.       );
  426.       ObjectOverrule.RemoveOverrule(
  427.         RXClass.GetClass(typeof(Circle)),
  428.         CirclePipeDrawOverrule.theOverrule
  429.       );
  430.       ObjectOverrule.RemoveOverrule(
  431.         RXClass.GetClass(typeof(Line)),
  432.         LinePipeTransformOverrule.theOverrule
  433.       );
  434.       ObjectOverrule.RemoveOverrule(
  435.         RXClass.GetClass(typeof(Circle)),
  436.         CirclePipeTransformOverrule.theOverrule
  437.       );
  438.       Overrule(false);
  439.     }
  441.     [CommandMethod("MP", CommandFlags.UsePickSet)]
  442.     public void MakePipe()
  443.     {
  444.       Document doc =
  445.         Application.DocumentManager.MdiActiveDocument;
  446.       Database db = doc.Database;
  447.       Editor ed = doc.Editor;
  449.       // Ask the user to select the entities to make into pipes
  451.       PromptSelectionOptions pso =
  452.         new PromptSelectionOptions();
  453.       pso.AllowDuplicates = false;
  454.       pso.MessageForAdding =
  455.         "\nSelect objects to turn into pipes: ";
  457.       PromptSelectionResult selRes =
  458.         doc.Editor.GetSelection(pso);
  460.       // If the user didn't make valid selection, we return
  462.       if (selRes.Status != PromptStatus.OK)
  463.         return;
  465.       SelectionSet ss = selRes.Value;
  467.       // Ask the user for the pipe radius to set
  469.       PromptDoubleOptions pdo =
  470.         new PromptDoubleOptions(
  471.           "\nSpecify pipe radius:"
  472.         );
  474.       // Use the previous value, if if already called
  476.       if (_radius > 0.0)
  477.       {
  478.         pdo.DefaultValue = _radius;
  479.         pdo.UseDefaultValue = true;
  480.       }
  481.       pdo.AllowNegative = false;
  482.       pdo.AllowZero = false;
  484.       PromptDoubleResult pdr =
  485.         ed.GetDouble(pdo);
  487.       // Return if something went wrong
  489.       if (pdr.Status != PromptStatus.OK)
  490.         return;
  492.       // Set the "last radius" value for when
  493.       // the command is called next
  495.       _radius = pdr.Value;
  497.       // Use a transaction to edit our various objects
  499.       Transaction tr =
  500.         db.TransactionManager.StartTransaction();
  501.       using (tr)
  502.       {
  503.         // Lop through the selected objects
  505.         foreach (SelectedObject o in ss)
  506.         {
  507.           // We could choose only to add XData to the objects
  508.           // we know will use it (Lines and Circles, for now)
  510.           DBObject obj =
  511.             tr.GetObject(o.ObjectId, OpenMode.ForWrite);
  512.           PipeDrawOverrule.SetPipeRadiusOnObject(tr, obj, _radius);
  513.         }
  514.         tr.Commit();
  515.       }
  516.     }
  517.   }
  518. }
As before we can create a bunch of lines and circles, assign them radii using the MP command, and then display them using the OVERRULE1 command:


Now when we perform our EXPLODE, selecting the various objects, and instead of a rejection message we get a set of Solid3D objects replacing our lines and circles:

Too cool! :-)
As you can hopefully see, the more you look at the Overrule API in AutoCAD 2010, the more power you uncover. Keep the comments & questions coming – it’s fun to see how this little application is evolving based on your feedback.

本帖子中包含更多资源

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

x
回复 支持 反对

使用道具 举报

雪山飞狐_lzh
 楼主| 发表于 2009-6-16 09:02 | 显示全部楼层
三、复制重定义
May 04, 2009
Using an AutoCAD 2010 overrule to control the copying of XData using .NET
It’s quite common for AutoCAD developers to use Extended Entity Data (XData) to tag objects their application cares about. This is certainly the approach taken in the recent series showing how to overrule the graphics display for an object – we store a “pipe radius” in XData attached to the Line or Circle we want to have a 3D profile.
That’s fine, but what if we’re storing a unique identifier with an object in XData that we do not want copied with the object? The Overrule API in AutoCAD 2010 allows you to hook into the DeepClone of an object and control what data gets copied with the object, whether via the COPY command or some other process that chooses to copy your object.
Here’s an example CopyOverrule class that makes use of the XData functions we previously defined as part of the PipeDrawOverrule class:
  2. public class CopyOverrule : ObjectOverrule
  3. {
  4.   static public CopyOverrule theOverrule =
  5.     new CopyOverrule();
  7.   public override DBObject DeepClone(
  8.     DBObject dbObject, DBObject ownerObject,
  9.     IdMapping idMap, bool isPrimary
  10.   )
  11.   {
  12.     // First we deep clone the object via the parent
  14.     DBObject res =
  15.       base.DeepClone(dbObject, ownerObject, idMap, isPrimary);
  17.     // Then we check for our XData
  19.     if (PipeDrawOverrule.PipeRadiusForObject(res) > 0.0)
  20.     {
  21.       // A transaction is needed by the set function to access
  22.       // the RegApp table - we could also assume the app name
  23.       // is registered and have a separate implementation
  24.       // not taking the transaction...        
  25.       // Just as we might also have chosen to remove the XData
  27.       Transaction tr =
  28.         dbObject.Database.TransactionManager.StartTransaction();
  29.       using (tr)
  30.       {
  31.         PipeDrawOverrule.SetPipeRadiusOnObject(tr, res, 0.0);
  32.         tr.Commit();
  33.       }
  34.     }
  35.     return res;
  36.   }
  37. }
In this code we call the DeepClone implementation in the parent class and set the result – the copy of our object – to the res variable. If there any additional objects were copied during the DeepClone process, there should be IdPair entries in the idMap variable referring to both the originator and the copy. In this code we just check the XData on the returned object, but we might also iterate through and check the contents of the idMap.
Also, rather than removing the XData – which some people might prefer to do, depending on the behaviour of their application – we just set it to 0. Which is enough to make sure the object’s graphic display doesn’t make use of a pipe radius.
Here’s the complete code, including the code to register and unregister the overrule in the OVERRULE0 and OVERRULE1 commands:
  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;
  7. using Autodesk.AutoCAD.GraphicsInterface;
  8. using Autodesk.AutoCAD.Colors;
  10. namespace DrawOverrules
  11. {
  12.   public abstract class PipeDrawOverrule : DrawableOverrule
  13.   {
  14.     const string regAppName = "TTIF_PIPE";
  16.     public PipeDrawOverrule()
  17.     {
  18.       // Tell AutoCAD to filter on our application name
  19.       // (this means our overrule will only be called
  20.       // on objects possessing XData with this name)
  22.       SetXDataFilter(regAppName);
  23.     }
  25.     // Get the XData for a particular object
  26.     // and return the "pipe radius" if it exists
  28.     public static double PipeRadiusForObject(DBObject obj)
  29.     {
  30.       double res = 0.0;
  32.       ResultBuffer rb = obj.XData;
  33.       if (rb != null)
  34.       {
  35.         bool foundStart = false;
  37.         foreach (TypedValue tv in rb)
  38.         {
  39.           if (tv.TypeCode == (int)DxfCode.ExtendedDataRegAppName &&
  40.               tv.Value.ToString() == regAppName)
  41.             foundStart = true;
  42.           else
  43.           {
  44.             if (foundStart == true)
  45.             {
  46.               if (tv.TypeCode == (int)DxfCode.ExtendedDataReal)
  47.               {
  48.                 res = (double)tv.Value;
  49.                 break;
  50.               }
  51.             }
  52.           }
  53.         }
  54.         rb.Dispose();
  55.       }
  56.       return res;
  57.     }
  59.     // Set the "pipe radius" in the XData of a particular object
  61.     public static void SetPipeRadiusOnObject(
  62.       Transaction tr, DBObject obj, double radius
  63.     )
  64.     {
  65.       Database db = obj.Database;
  67.       // Make sure the application is registered
  68.       // (we could separate this out to be called
  69.       // only once for a set of operations)
  71.       RegAppTable rat =
  72.         (RegAppTable)tr.GetObject(
  73.           db.RegAppTableId,
  74.           OpenMode.ForRead
  75.         );
  77.       if (!rat.Has(regAppName))
  78.       {
  79.         rat.UpgradeOpen();
  80.         RegAppTableRecord ratr = new RegAppTableRecord();
  81.         ratr.Name = regAppName;
  82.         rat.Add(ratr);
  83.         tr.AddNewlyCreatedDBObject(ratr, true);
  84.       }
  86.       // Create the XData and set it on the object
  88.       ResultBuffer rb =
  89.         new ResultBuffer(
  90.           new TypedValue(
  91.             (int)DxfCode.ExtendedDataRegAppName, regAppName
  92.           ),
  93.           new TypedValue(
  94.             (int)DxfCode.ExtendedDataReal, radius
  95.           )
  96.         );
  97.       obj.XData = rb;
  98.       rb.Dispose();
  99.     }
  100.   }
  102.   // An overrule to make a pipe out of line
  104.   public class LinePipeDrawOverrule : PipeDrawOverrule
  105.   {
  106.     static public LinePipeDrawOverrule theOverrule =
  107.       new LinePipeDrawOverrule();
  109.     private SweepOptions sweepOpts = new SweepOptions();
  111.     public override bool WorldDraw(Drawable d, WorldDraw wd)
  112.     {
  113.       double radius = 0.0;
  115.       if (d is DBObject)
  116.         radius = PipeRadiusForObject((DBObject)d);
  118.       if (radius > 0.0)
  119.       {
  120.         Line line = d as Line;
  122.         if (line != null)
  123.         {
  124.           // Draw the line as is, with overruled attributes
  126.           base.WorldDraw(line, wd);
  127.           if (!line.Id.IsNull && line.Length > 0.0)
  128.           {
  129.             // Draw a pipe around the line
  131.             EntityColor c =
  132.               wd.SubEntityTraits.TrueColor;
  133.             wd.SubEntityTraits.TrueColor =
  134.               new EntityColor(0x00AfAfff);
  135.             wd.SubEntityTraits.LineWeight =
  136.               LineWeight.LineWeight000;
  137.             Circle clr =
  138.               new Circle(
  139.                 line.StartPoint,
  140.                 line.EndPoint - line.StartPoint,
  141.                 radius
  142.               );
  143.             ExtrudedSurface pipe = new ExtrudedSurface();
  144.             try
  145.             {
  146.               pipe.CreateExtrudedSurface(
  147.                 clr, line.EndPoint - line.StartPoint, sweepOpts
  148.               );
  149.             }
  150.             catch
  151.             {
  152.               Document doc =
  153.                 Application.DocumentManager.MdiActiveDocument;
  154.               doc.Editor.WriteMessage(
  155.                 "\nFailed with CreateExtrudedSurface."
  156.               );
  157.             }
  158.             clr.Dispose();
  159.             pipe.WorldDraw(wd);
  160.             pipe.Dispose();
  161.             wd.SubEntityTraits.TrueColor = c;
  162.           }
  163.           return true;
  164.         }
  165.       }
  166.       return base.WorldDraw(d, wd);
  167.     }
  169.     public override int SetAttributes(Drawable d, DrawableTraits t)
  170.     {
  171.       int b = base.SetAttributes(d, t);
  173.       double radius = 0.0;
  175.       if (d is DBObject)
  176.         radius = PipeRadiusForObject((DBObject)d);
  178.       if (radius > 0.0)
  179.       {
  180.         // Set color to index 6
  182.         t.Color = 6;
  184.         // and lineweight to .40 mm
  186.         t.LineWeight = LineWeight.LineWeight040;
  187.       }
  188.       return b;
  189.     }
  190.   }
  192.   // An overrule to make a pipe out of circle
  194.   public class CirclePipeDrawOverrule : PipeDrawOverrule
  195.   {
  196.     static public CirclePipeDrawOverrule theOverrule =
  197.       new CirclePipeDrawOverrule();
  199.     private SweepOptions sweepOpts = new SweepOptions();
  201.     public override bool WorldDraw(Drawable d, WorldDraw wd)
  202.     {
  203.       double radius = 0.0;
  205.       if (d is DBObject)
  206.         radius = PipeRadiusForObject((DBObject)d);
  208.       if (radius > 0.0)
  209.       {
  210.         Circle circle = d as Circle;
  212.         if (circle != null)
  213.         {
  214.           // Draw the circle as is, with overruled attributes
  216.           base.WorldDraw(circle, wd);
  218.           // Needed to avoid ill-formed swept surface
  220.           if (circle.Radius > radius)
  221.           {
  222.             // Draw a pipe around the cirle
  224.             EntityColor c = wd.SubEntityTraits.TrueColor;
  225.             wd.SubEntityTraits.TrueColor =
  226.               new EntityColor(0x3fffe0e0);
  227.             wd.SubEntityTraits.LineWeight =
  228.               LineWeight.LineWeight000;
  229.             Vector3d normal =
  230.               (circle.Center - circle.StartPoint).
  231.                 CrossProduct(circle.Normal);
  232.             Circle clr =
  233.               new Circle(
  234.                 circle.StartPoint, normal, radius
  235.               );
  236.             SweptSurface pipe = new SweptSurface();
  237.             pipe.CreateSweptSurface(clr, circle, sweepOpts);
  238.             clr.Dispose();
  239.             pipe.WorldDraw(wd);
  240.             pipe.Dispose();
  241.             wd.SubEntityTraits.TrueColor = c;
  242.           }
  243.           return true;
  244.         }
  245.       }
  246.       return base.WorldDraw(d, wd);
  247.     }
  249.     public override int SetAttributes(Drawable d, DrawableTraits t)
  250.     {
  251.       int b = base.SetAttributes(d, t);
  253.       double radius = 0.0;
  255.       if (d is DBObject)
  256.         radius = PipeRadiusForObject((DBObject)d);
  258.       if (radius > 0.0)
  259.       {
  260.         // Set color to index 2
  262.         t.Color = 2;
  264.         // and lineweight to .60 mm
  266.         t.LineWeight = LineWeight.LineWeight060;
  267.       }
  268.       return b;
  269.     }
  270.   }
  272.   public class LinePipeTransformOverrule : TransformOverrule
  273.   {
  274.     static public LinePipeTransformOverrule theOverrule =
  275.       new LinePipeTransformOverrule();
  277.     private SweepOptions sweepOpts = new SweepOptions();
  279.     public override void Explode(Entity e, DBObjectCollection objs)
  280.     {
  281.       double radius = 0.0;
  283.       if (e is DBObject)
  284.         radius = PipeDrawOverrule.PipeRadiusForObject(e);
  286.       if (radius > 0.0)
  287.       {
  288.         Line line = e as Line;
  290.         if (line != null)
  291.         {
  292.           if (!line.Id.IsNull && line.Length > 0.0)
  293.           {
  294.             // Draw a pipe around the line
  296.             Circle clr =
  297.               new Circle(
  298.                 line.StartPoint,
  299.                 line.EndPoint - line.StartPoint,
  300.                 radius
  301.               );
  302.             ExtrudedSurface pipe = new ExtrudedSurface();
  303.             try
  304.             {
  305.               pipe.CreateExtrudedSurface(
  306.                 clr, line.EndPoint - line.StartPoint, sweepOpts
  307.               );
  308.             }
  309.             catch
  310.             {
  311.               Document doc =
  312.                 Application.DocumentManager.MdiActiveDocument;
  313.               doc.Editor.WriteMessage(
  314.                 "\nFailed with CreateExtrudedSurface."
  315.               );
  316.             }
  317.             clr.Dispose();
  318.             objs.Add(pipe);
  319.           }
  320.           return;
  321.         }
  322.       }
  323.       base.Explode(e, objs);
  324.     }
  325.   }
  327.   public class CirclePipeTransformOverrule : TransformOverrule
  328.   {
  329.     static public CirclePipeTransformOverrule theOverrule =
  330.       new CirclePipeTransformOverrule();
  332.     private SweepOptions sweepOpts = new SweepOptions();
  334.     public override void Explode(Entity e, DBObjectCollection objs)
  335.     {
  336.       double radius = 0.0;
  338.       if (e is DBObject)
  339.         radius = PipeDrawOverrule.PipeRadiusForObject(e);
  341.       if (radius > 0.0)
  342.       {
  343.         Circle circle = e as Circle;
  345.         if (circle != null)
  346.         {
  347.           // Needed to avoid ill-formed swept surface
  349.           if (circle.Radius > radius)
  350.           {
  351.             // Draw a pipe around the cirle
  353.             Vector3d normal =
  354.               (circle.Center - circle.StartPoint).
  355.                 CrossProduct(circle.Normal);
  356.             Circle clr =
  357.               new Circle(
  358.                 circle.StartPoint, normal, radius
  359.               );
  360.             SweptSurface pipe = new SweptSurface();
  361.             pipe.CreateSweptSurface(clr, circle, sweepOpts);
  362.             clr.Dispose();
  363.             objs.Add(pipe);
  364.           }
  365.           return;
  366.         }
  367.       }
  368.       base.Explode(e, objs);
  369.     }
  370.   }
  372.   public class CopyOverrule : ObjectOverrule
  373.   {
  374.     static public CopyOverrule theOverrule =
  375.       new CopyOverrule();
  377.     public override DBObject DeepClone(
  378.       DBObject dbObject, DBObject ownerObject,
  379.       IdMapping idMap, bool isPrimary
  380.     )
  381.     {
  382.       // First we deep clone the object via the parent
  384.       DBObject res =
  385.         base.DeepClone(dbObject, ownerObject, idMap, isPrimary);
  387.       // Then we check for our XData
  389.       if (PipeDrawOverrule.PipeRadiusForObject(res) > 0.0)
  390.       {
  391.         // A transaction is needed by the set function to access
  392.         // the RegApp table - we could also assume the app name
  393.         // is registered and have a separate implementation
  394.         // not taking the transaction...        
  395.         // Just as we might also have chosen to remove the XData
  397.         Transaction tr =
  398.           dbObject.Database.TransactionManager.StartTransaction();
  399.         using (tr)
  400.         {
  401.           PipeDrawOverrule.SetPipeRadiusOnObject(tr, res, 0.0);
  402.           tr.Commit();
  403.         }
  404.       }
  405.       return res;
  406.     }
  407.   }
  409.   public class Commands
  410.   {
  411.     private double _radius = 0.0;
  413.     public void Overrule(bool enable)
  414.     {
  415.       // Regen to see the effect
  416.       // (turn on/off Overruling and LWDISPLAY)
  418.       DrawableOverrule.Overruling = enable;
  419.       if (enable)
  420.         Application.SetSystemVariable("LWDISPLAY", 1);
  421.       else
  422.         Application.SetSystemVariable("LWDISPLAY", 0);
  424.       Document doc =
  425.         Application.DocumentManager.MdiActiveDocument;
  426.       doc.SendStringToExecute("REGEN3\n", true, false, false);
  427.       doc.Editor.Regen();
  428.     }
  430.     [CommandMethod("OVERRULE1")]
  431.     public void OverruleStart()
  432.     {
  433.       ObjectOverrule.AddOverrule(
  434.         RXClass.GetClass(typeof(Line)),
  435.         LinePipeDrawOverrule.theOverrule,
  436.         true
  437.       );
  438.       ObjectOverrule.AddOverrule(
  439.         RXClass.GetClass(typeof(Circle)),
  440.         CirclePipeDrawOverrule.theOverrule,
  441.         true
  442.       );
  443.       ObjectOverrule.AddOverrule(
  444.         RXClass.GetClass(typeof(Line)),
  445.         LinePipeTransformOverrule.theOverrule,
  446.         true
  447.       );
  448.       ObjectOverrule.AddOverrule(
  449.         RXClass.GetClass(typeof(Circle)),
  450.         CirclePipeTransformOverrule.theOverrule,
  451.         true
  452.       );
  453.       ObjectOverrule.AddOverrule(
  454.         RXClass.GetClass(typeof(Entity)),
  455.         CopyOverrule.theOverrule,
  456.         true
  457.       );
  458.       Overrule(true);
  459.     }
  461.     [CommandMethod("OVERRULE0")]
  462.     public void OverruleEnd()
  463.     {
  464.       ObjectOverrule.RemoveOverrule(
  465.         RXClass.GetClass(typeof(Line)),
  466.         LinePipeDrawOverrule.theOverrule
  467.       );
  468.       ObjectOverrule.RemoveOverrule(
  469.         RXClass.GetClass(typeof(Circle)),
  470.         CirclePipeDrawOverrule.theOverrule
  471.       );
  472.       ObjectOverrule.RemoveOverrule(
  473.         RXClass.GetClass(typeof(Line)),
  474.         LinePipeTransformOverrule.theOverrule
  475.       );
  476.       ObjectOverrule.RemoveOverrule(
  477.         RXClass.GetClass(typeof(Circle)),
  478.         CirclePipeTransformOverrule.theOverrule
  479.       );
  480.       ObjectOverrule.RemoveOverrule(
  481.         RXClass.GetClass(typeof(Entity)),
  482.         CopyOverrule.theOverrule
  483.       );
  484.       Overrule(false);
  485.     }
  487.     [CommandMethod("MP", CommandFlags.UsePickSet)]
  488.     public void MakePipe()
  489.     {
  490.       Document doc =
  491.         Application.DocumentManager.MdiActiveDocument;
  492.       Database db = doc.Database;
  493.       Editor ed = doc.Editor;
  495.       // Ask the user to select the entities to make into pipes
  497.       PromptSelectionOptions pso =
  498.         new PromptSelectionOptions();
  499.       pso.AllowDuplicates = false;
  500.       pso.MessageForAdding =
  501.         "\nSelect objects to turn into pipes: ";
  503.       PromptSelectionResult selRes =
  504.         doc.Editor.GetSelection(pso);
  506.       // If the user didn't make valid selection, we return
  508.       if (selRes.Status != PromptStatus.OK)
  509.         return;
  511.       SelectionSet ss = selRes.Value;
  513.       // Ask the user for the pipe radius to set
  515.       PromptDoubleOptions pdo =
  516.         new PromptDoubleOptions(
  517.           "\nSpecify pipe radius:"
  518.         );
  520.       // Use the previous value, if if already called
  522.       if (_radius > 0.0)
  523.       {
  524.         pdo.DefaultValue = _radius;
  525.         pdo.UseDefaultValue = true;
  526.       }
  527.       pdo.AllowNegative = false;
  528.       pdo.AllowZero = false;
  530.       PromptDoubleResult pdr =
  531.         ed.GetDouble(pdo);
  533.       // Return if something went wrong
  535.       if (pdr.Status != PromptStatus.OK)
  536.         return;
  538.       // Set the "last radius" value for when
  539.       // the command is called next
  541.       _radius = pdr.Value;
  543.       // Use a transaction to edit our various objects
  545.       Transaction tr =
  546.         db.TransactionManager.StartTransaction();
  547.       using (tr)
  548.       {
  549.         // Loop through the selected objects
  551.         foreach (SelectedObject o in ss)
  552.         {
  553.           // We could choose only to add XData to the objects
  554.           // we know will use it (Lines and Circles, for now)
  556.           DBObject obj =
  557.             tr.GetObject(o.ObjectId, OpenMode.ForWrite);
  558.           PipeDrawOverrule.SetPipeRadiusOnObject(tr, obj, _radius);
  559.         }
  560.         tr.Commit();
  561.       }
  562.     }
  563.   }
  564. }
Let’s see what happens when we attempt to copy a circular pipe using the standard COPY command (after having first created it using MP and have it display using OVERRULE1). We can see that as we select the location, the circle is displayed with a pipe radius:

But once we specify the location, the circle’s radius is removed:

本帖子中包含更多资源

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

x
回复 支持 反对

使用道具 举报

雪山飞狐_lzh
 楼主| 发表于 2009-6-16 09:10 | 显示全部楼层
四、在属性窗口中显示和修改自定义属性
May 06, 2009
Modifying an AutoCAD object’s state via a dynamic property defined using .NET
I’ve been meaning to get to this one for a while. This post takes the OPM .NET implementation and shows how to use it to allow modification of data persisted with an object: in this case we’re going to use the XData in which we store the “pipe radius” for the AutoCAD 2010 overrule sample we’ve recently been developing.
To start with, I needed to migrate the OPM .NET module to work with AutoCAD 2010, which meant installing Visual Studio 2008 SP1. Other than that the code migrated very easily, and the project (with the built asdkOPMNetExt.dll assembly) can be found here. I recommend placing the module in AutoCAD’s main program folder and having it demand-load on AutoCAD startup (if you choose to use it).
[A quick comment on that, as I know some people dislike doing this... it's highly recommended to place your .NET assemblies in AutoCAD's main program folder: you will avoid a whole category of subtle problems by doing so. You needn't feel it's dangerous as long as you prefix the filename of each of your modules with your Registered Developer Symbol (RDS).]
Here’s the C# code to add to our overrule application:
  2. using Autodesk.AutoCAD.ApplicationServices;
  3. using Autodesk.AutoCAD.DatabaseServices;
  4. using Autodesk.AutoCAD.Runtime;
  5. using Autodesk.AutoCAD.Windows.OPM;
  6. using Autodesk.AutoCAD.Interop.Common;
  7. using System.Runtime.InteropServices;
  8. using System.Reflection;
  9. using System;
  10. using DrawOverrules;
  12. namespace PropertyEditing
  13. {
  14.   #region Our Custom Property
  15.   [
  16.     Guid("E64CAA14-EA92-46ea-82D6-420FA873F16F"),
  17.     ProgId("OverruleSample.PipeRadius.1"),
  18.     ClassInterface(ClassInterfaceType.None),
  19.     ComDefaultInterface(typeof(IDynamicProperty2)),
  20.     ComVisible(true)
  21.   ]
  22.   public class CustomProp : IDynamicProperty2
  23.   {
  24.     private IDynamicPropertyNotify2 m_pSink = null;
  26.     // Unique property ID
  28.     public void GetGUID(out Guid propGUID)
  29.     {
  30.       propGUID =
  31.         new Guid("F60AE3DA-0373-4d24-82D2-B2646517ABCB");
  32.     }
  34.     // Property display name
  36.     public void GetDisplayName(out string szName)
  37.     {
  38.       szName = "Pipe radius";
  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.         "Radius of the pipe profile applied to this linear entity.";
  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, VT_I4, VT_R4, VT_R8,VT_BSTR, VT_BOOL
  79.       // and VT_USERDEFINED.
  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.       // Get the value and return it to AutoCAD
  91.       AcadObject obj = pUnk as AcadObject;
  92.       if (obj != null)
  93.       {
  94.         Document doc =
  95.           Application.DocumentManager.MdiActiveDocument;
  96.         Transaction tr =
  97.           doc.TransactionManager.StartTransaction();
  98.         using (tr)
  99.         {
  100.           DBObject o =
  101.             tr.GetObject(
  102.               new ObjectId((IntPtr)obj.ObjectID),
  103.               OpenMode.ForRead
  104.             );
  105.           pVarData =
  106.             PipeDrawOverrule.PipeRadiusForObject(o);
  107.         }
  108.       }
  109.       else
  110.         pVarData = 0.0;
  111.     }
  113.     // Set the property value, passes the specific object we
  114.     // want to set the property value for
  116.     public void SetCurrentValueData(object pUnk, object varData)
  117.     {
  118.       // Save the value returned to you
  120.       AcadObject obj = pUnk as AcadObject;
  121.       if (obj != null)
  122.       {
  123.         Document doc =
  124.           Application.DocumentManager.MdiActiveDocument;
  125.         DocumentLock dl =
  126.           doc.LockDocument(
  127.             DocumentLockMode.ProtectedAutoWrite,
  128.             null, null, true
  129.           );        
  130.         using (dl)
  131.         {
  132.           Transaction tr =
  133.             doc.TransactionManager.StartTransaction();
  134.           using (tr)
  135.           {
  136.             DBObject o =
  137.               tr.GetObject(
  138.                 new ObjectId((IntPtr)obj.ObjectID),
  139.                 OpenMode.ForWrite
  140.               );
  141.             PipeDrawOverrule.SetPipeRadiusOnObject(
  142.               tr, o, (float)varData
  143.             );
  144.             tr.Commit();
  145.           }
  146.         }
  147.       }
  148.     }
  150.     // OPM passes its implementation of IDynamicPropertyNotify, you
  151.     // cache it and call it to inform OPM your property has changed
  153.     public void Connect(object pSink)
  154.     {
  155.       m_pSink = (IDynamicPropertyNotify2)pSink;
  156.     }
  158.     public void Disconnect()
  159.     {
  160.       m_pSink = null;
  161.     }
  162.   }
  163.   #endregion
  165.   #region Application Entry Point
  166.   public class MyEntryPoint : IExtensionApplication
  167.   {
  168.     protected internal CustomProp custProp = null;
  170.     public void Initialize()
  171.     {
  172.       Assembly.LoadFrom("asdkOPMNetExt.dll");
  174.       // Add the Dynamic Property to Lines and Circles
  175.       // (might add it at the Entity level, instead)
  177.       Dictionary classDict = SystemObjects.ClassDictionary;
  178.       RXClass lineDesc = (RXClass)classDict.At("AcDbLine");
  179.       RXClass cirDesc = (RXClass)classDict.At("AcDbCircle");
  180.       custProp = new CustomProp();
  181.       IPropertyManager2 pPropMan =
  182.         (IPropertyManager2)xOPM.xGET_OPMPROPERTY_MANAGER(lineDesc);
  183.       pPropMan.AddProperty((object)custProp);
  184.       pPropMan =
  185.         (IPropertyManager2)xOPM.xGET_OPMPROPERTY_MANAGER(cirDesc);
  186.       pPropMan.AddProperty((object)custProp);
  187.     }
  189.     public void Terminate()
  190.     {
  191.       // Remove the Dynamic Property
  193.       Dictionary classDict = SystemObjects.ClassDictionary;
  194.       RXClass lineDesc = (RXClass)classDict.At("AcDbLine");
  195.       RXClass cirDesc = (RXClass)classDict.At("AcDbCircle");
  196.       IPropertyManager2 pPropMan =
  197.         (IPropertyManager2)xOPM.xGET_OPMPROPERTY_MANAGER(lineDesc);
  198.       pPropMan.RemoveProperty((object)custProp);
  199.       pPropMan =
  200.         (IPropertyManager2)xOPM.xGET_OPMPROPERTY_MANAGER(cirDesc);
  201.       pPropMan.RemoveProperty((object)custProp);
  202.       custProp = null;
  203.     }
  204.   }
  205.   #endregion
  206. }

Some comments on the implementation:
GetCurrentValueData() and SetCurrentValueData() both have to open the object to access it’s .NET protocol
We might also have used COM to access the XData, but this approach reuses previously-developed code
To modify the object we need to lock the current document
We use the ProtectedAutoWrite locking mode for this, so that all our property edits are grouped into a single undo group
We use the “protected” version of the locking mode as there’s a lock needed elsewhere, probably in the drawing code. If we use the standard AutoWrite lock we get an eLockViolation message
We’re using a new transaction for each read/modification
This feels like overkill, but then as we’re in an UI-bound operation it’s unlikely to have a perceived performance impact
We’re also using the static protocol from the DrawOverrule class for the XData retrieval/setting
With hindsight this probably should live in its own helper class, which is the original way I had it :-S :-)
Here’s a model we’re going to modify using the Properties Palette:

Now we select one of our overruled objects – a circle – and see it's new dynamic property:

When we select all our objects, we see the property varies:

Now we modify the property to be the same for all our objects:

And we can see the result of our modification:

You can see that the property currently isn’t categorised: as mentioned previously, we would have to implement ICategorizedProperty in our OPM .NET module for this to be possible. Which I will attempt, one day.

本帖子中包含更多资源

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

x
回复 支持 反对

使用道具 举报

雪山飞狐_lzh
 楼主| 发表于 2009-6-16 09:16 | 显示全部楼层
五、使用重定义亮显特定名字的块参照
June 15, 2009
Highlighting named blocks using AutoCAD 2010’s overrule API from .NET
This is a nice sample provided by Stephen Preston, who manages DevTech’s Americas team. Stephen has put this together in anticipation of his upcoming AU class on the overrule API introduced in AutoCAD 2010. [I know the final class list has not yet been announced, but Stephen is co-owner of the Customization & Programming track at this year’s AU and presumably has the inside skinny on the selected classes. Which means he has a head-start on preparing his material, lucky fellow. :-)]
The sample allows the user to enter a text string that it uses to highlight any block containing that string in its name. This is quite handy for identifying the instances of a particular block in a drawing, but it might also be modified to highlight other objects (you might want to highlight mis-spelt words or standards violations, for instance).
Here’s the C# code, reformatted for this blog:
  2. using System;
  3. using Autodesk.AutoCAD.Runtime;
  4. using Autodesk.AutoCAD.ApplicationServices;
  5. using Autodesk.AutoCAD.DatabaseServices;
  6. using Autodesk.AutoCAD.Geometry;
  7. using Autodesk.AutoCAD.EditorInput;
  8. using Autodesk.AutoCAD.GraphicsInterface;
  10. namespace MyCustomFilterOverrule
  11. {
  12.   // This is our custom DrawableOverrule class. We're just
  13.   // overruling WorldDraw and IsApplicable.
  14.   // This class is implemented as a singleton class, and
  15.   // includes subroutines that are called by the CommandMethods
  16.   // in another class
  18.   public class MyDrawOverrule : DrawableOverrule
  19.   {
  20.     // Where properties have been defined, use the property rather
  21.     // than the raw variable.
  22.     // I'm using properties where I need some additional logic to
  23.     // run as I get/set the variable.
  25.     // The text we'll search for in our block name.
  27.     private string mTxt;
  29.     // Color Index of block highlight
  31.     private short mColor = 3;
  33.     // Used to track whether this Overrule has been registered
  34.     // (so we don't try to register it more than once).
  36.     private bool mRegistered = false;
  38.     // Used to store one and only instance of our singleton class
  40.     private static MyDrawOverrule mSingleton;
  42.     // Used to reset Overruling value to the value it had before
  43.     // we switched them on. (There may be other overrules in place)
  45.     private static bool mOldOverruleValue;
  47.     // The color we highlight blocks with
  48.     private short HighlightColor
  49.     {
  50.       get { return mColor; }
  51.       set { if (value >= 0 && value <= 127) mColor = value; }
  52.     }
  54.     // The text we'll search for in the block name
  56.     private string SearchText
  57.     {
  58.       get { return mTxt; }
  59.       set { mTxt = value; }
  60.     }
  62.     // Private constructor because its a singleton
  64.     private MyDrawOverrule()
  65.     {
  66.       // Do nothing
  67.     }
  69.     // Shared propery to return our singleton instance
  70.     // (and instantiate new instance on first call)
  72.     public static MyDrawOverrule GetInstance
  73.     {
  74.       get
  75.       {
  76.         if (mSingleton == null)
  77.         {
  78.           mSingleton = new MyDrawOverrule();
  79.         }
  80.         return mSingleton;
  81.       }
  82.     }
  84.     private void InitOverrule()
  85.     {
  86.       if (!mRegistered)
  87.       {
  88.         Overrule.AddOverrule(
  89.           RXObject.GetClass(typeof(BlockReference)), this, false
  90.         );
  91.         SetCustomFilter();
  92.         mOldOverruleValue = Overrule.Overruling;
  93.         mRegistered = true;
  94.       }
  95.       Overrule.Overruling = true;
  96.     }
  98.     // Prompts user to select the color index they want to
  99.     // highlight blocks with
  101.     public void SetColor()
  102.     {
  103.       Editor ed =
  104.         Application.DocumentManager.MdiActiveDocument.Editor;
  106.       PromptIntegerOptions opts =
  107.         new PromptIntegerOptions(
  108.           "\nEnter block finder color index: "
  109.         );
  110.       opts.DefaultValue = HighlightColor;
  111.       opts.LowerLimit = 0;
  112.       opts.UpperLimit = 127;
  113.       opts.UseDefaultValue = true;
  114.       PromptIntegerResult res = ed.GetInteger(opts);
  116.       // If requested highlight color is a new color,
  117.       // then we want to change it
  119.       if (res.Status == PromptStatus.OK &&
  120.           HighlightColor != res.Value)
  121.       {
  122.         HighlightColor = (short)res.Value;
  124.         // Regen is required to update changes on screen
  126.         ed.Regen();
  127.       }
  128.     }
  130.     public void FindText()
  131.     {
  132.       Editor ed =
  133.         Application.DocumentManager.MdiActiveDocument.Editor;
  135.       ed.WriteMessage(
  136.         "\nCurrent block search text is "{0}".", SearchText
  137.       );
  138.       PromptStringOptions opts =
  139.         new PromptStringOptions(
  140.           "\nEnter new block search text: "
  141.         );
  142.       PromptResult res = ed.GetString(opts);
  144.       // If the user cancelled then we exit the command
  146.       if (res.Status != PromptStatus.OK)
  147.         return;
  149.       // If the user didn't type any text then we remove
  150.       // the overrule and exit
  152.       if (res.StringResult == "")
  153.       {
  154.         SearchText = "";
  155.         ResetBlocks();
  156.       }
  157.       else
  158.       {
  159.         // Set search text for Overrule to that entered by user
  161.         SearchText = res.StringResult.ToUpper();
  162.         InitOverrule();
  164.         // Turn Overruling on
  166.         Overrule.Overruling = true;
  168.         // Regen is required to update changes on screen.
  170.         ed.Regen();
  171.       }
  172.     }
  174.     // Removes our overrules
  176.     public void ResetBlocks()
  177.     {
  178.       Editor ed =
  179.         Application.DocumentManager.MdiActiveDocument.Editor;
  181.       Overrule.Overruling = mOldOverruleValue;
  182.       if (mRegistered)
  183.       {
  184.         Overrule.RemoveOverrule(
  185.           RXObject.GetClass(typeof(BlockReference)), this
  186.         );
  187.         mRegistered = false;
  188.         ed.Regen();
  189.       }
  190.     }
  192.     // Overrule WorldDraw so we can draw our additional
  193.     // graphics
  195.     public override bool WorldDraw(Drawable drawable, WorldDraw wd)
  196.     {
  197.       // Better safe than sorry - check it really is a
  198.       // BlockReference before continuing.
  200.       BlockReference br = drawable as BlockReference;
  201.       if (br != null)
  202.       {
  203.         // Now we want to draw a green box around the attributes
  204.         // extents
  206.         Extents3d ext = (Extents3d)br.Bounds;
  207.         Point3d maxPt = ext.MaxPoint;
  208.         Point3d minPt = ext.MinPoint;
  209.         Point3dCollection pts = new Point3dCollection();
  211.         // These are the vertices of the highlight box
  213.         pts.Add(new Point3d(minPt.X, minPt.Y, minPt.Z));
  214.         pts.Add(new Point3d(minPt.X, maxPt.Y, minPt.Z));
  215.         pts.Add(new Point3d(maxPt.X, maxPt.Y, minPt.Z));
  216.         pts.Add(new Point3d(maxPt.X, minPt.Y, minPt.Z));
  218.         // Store current filltype and set to FillAlways
  220.         FillType oldFillType = wd.SubEntityTraits.FillType;
  221.         wd.SubEntityTraits.FillType = FillType.FillAlways;
  223.         // Store old graphics color and set to the color we want
  225.         short oldColor = wd.SubEntityTraits.Color;
  226.         wd.SubEntityTraits.Color = HighlightColor;
  228.         // Draw the filled polygon
  230.         wd.Geometry.Polygon(pts);
  232.         // Restore old settings
  234.         wd.SubEntityTraits.FillType = oldFillType;
  235.         wd.SubEntityTraits.Color = oldColor;
  236.       }
  238.       // Let the overruled Drawable draw itself.
  240.       return base.WorldDraw(drawable, wd);
  241.     }
  243.     // This function is called if we call SetCustomFilter on our
  244.     // custom overrule.
  245.     // We add our own code to return true if the BlockReference
  246.     // passed in is one we want to highlight.
  248.     public override bool IsApplicable(RXObject overruledSubject)
  249.     {
  250.       // If it's a BlockReference, we check if the Block Name
  251.       // contains our string
  253.       BlockReference br = overruledSubject as BlockReference;
  254.       if (br != null && SearchText != "")
  255.       {
  256.         // Returns whether the filter is applicable to this object
  258.         return br.Name.Contains(SearchText);
  259.       }
  261.       // Only get to here if object isn't a BlockReference
  263.       return false;
  264.     }
  265.   }
  267.   // Our command class, which relays commands to MyDrawOverrule.
  269.   public class myPlugin
  270.   {
  271.     [CommandMethod("SHOWBLOCKS")]
  272.     public static void FindText()
  273.     {
  274.       MyDrawOverrule.GetInstance.FindText();
  275.     }
  277.     [CommandMethod("SHOWCOLOR")]
  278.     public static void SetColor()
  279.     {
  280.       MyDrawOverrule.GetInstance.SetColor();
  281.     }
  282.   }
  283. }

Here’s what happens when we OPEN the “Mechanical – Multileaders.dwg” sample drawing, NETLOAD our application and use SHOWBLOCKS to look for the “M045” text string:

Here’s what we see if we broaden the search to include all blocks with the string “M0” in their name and change the highlight colour to 1 using SHOWCOLOR:

To clear the selection, the user simply has to run SHOWBLOCKS and specify an empty string as the search term.
Stephen will be presenting both C# and VB.NET versions of this sample application during his class at this year’s AU. If you find overrules interesting, then I strongly recommend signing up for the session (I’ll let you know when registrations are open). I’m sure that during the class Stephen will be demonstrating other interesting capabilities made available to AutoCAD .NET developers by this very cool API.

本帖子中包含更多资源

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

x
回复 支持 反对

使用道具 举报

雪山飞狐_lzh
 楼主| 发表于 2009-9-6 20:05 | 显示全部楼层
六、捕获夹点操作时的图元
August 03, 2009
Knowing when an AutoCAD object is grip-edited using overrules in .NET
This week I will mostly be posting about Overrules. [For those of you who haven’t seen  The Fast Show (called Brilliant in the US), this is an obscure reference to a character named Jesse. :-)]
Aside from this post, Stephen Preston has sent me the samples he’s put together for his AU class on this topic, so expect some serious plagiarism (although now that I’ve given him credit I suppose it’s not really plagiarism :-).
Here’s a question I received recently by email:
    Is there some posibility to write something in some of your next blogs about how to get coordinate of grip when user move on screen in realtime. By using grip_stretch command...
    Example: we first draw polyline, then select it and move grip point...how we can know current position for grip coordinate before user pick point...in realtime...
Coincidentally I’ve been working on an internal project that uses Overrules to achieve this (or something quite similar). As I expect I’ve said before, AutoCAD 2010’s Overrule API is an incredibly powerful mechanism for hooking into and controlling object behaviour: it’s essentially our approach for providing the equivalent of custom object support to .NET programmers (which was the top item for a number of years on AutoCAD’s API wishlist).
To hook into object modification inside AutoCAD, we have a couple of options:
    * A TransformOverrule allows us to hook into an object’s TransformBy(), which tells use when it’s rotated, scaled or moved.
          o This is effective at trapping object-level transformations, whether via grips or commands such as MOVE, but won’t tell you when a specific vertex is modified (for instance)
    * A GripOverrule allows us to hook into GetGripPointsAt() and MoveGripPointsAt(), which can tell use when a grip-stretch is performed on our object.
          o This gives us more fine-grained information on a per-grip basis, but clearly won’t be called for commands such as MOVE which bypass the use of grips.
In this particular instance it makes more sense to use a GripOverrule, as we need to know when a particular polyline vertex is edited.
Here’s some C# code that implements a GripOverrule for AutoCAD entities (it works just as well for any entity with grips implemented via GetGripPointsAt() & MoveGripPointsAt(), so there’s no need to limit it just to Polylines, even if we could very easily).
  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 GripOverruleTest
  10. {
  11.   public class GripVectorOverrule : GripOverrule
  12.   {
  13.     // A static pointer to our overrule instance
  15.     static public GripVectorOverrule theOverrule =
  16.       new GripVectorOverrule();
  18.     // A flag to indicate whether we're overruling
  20.     static bool overruling = false;
  22.     // A single set of grips would not have worked in
  23.     // the case where multiple objects were selected.
  25.     static Dictionary<string, Point3dCollection> _gripDict =
  26.       new Dictionary<string, Point3dCollection>();
  28.     public GripVectorOverrule()
  29.     {
  30.     }
  32.     private string GetKey(Entity e)
  33.     {
  34.       // Generate a key based on the name of the object's type
  35.       // and its geometric extents
  37.       // (We cannot use the ObjectId, as this is null during
  38.       // grip-stretch operations.)
  40.       return e.GetType().Name + ":" + e.GeometricExtents.ToString();
  41.     }
  43.     // Save the locations of the grips for a particular entity
  45.     private void StoreGripInfo(Entity e, Point3dCollection grips)
  46.     {
  47.       string key = GetKey(e);
  48.       if (_gripDict.ContainsKey(key))
  49.       {
  50.         // Clear the grips if any already associated
  52.         Point3dCollection grps = _gripDict[key];
  53.         using (grps)
  54.         {
  55.           grps.Clear();
  56.         }
  57.         _gripDict.Remove(key);
  58.       }
  60.       // Now we add our grips
  62.       Point3d[] pts = new Point3d[grips.Count];
  63.       grips.CopyTo(pts, 0);
  64.       Point3dCollection gps = new Point3dCollection(pts);
  65.       _gripDict.Add(key, gps);
  66.     }
  68.     // Get the locations of the grips for an entity
  70.     private Point3dCollection RetrieveGripInfo(Entity e)
  71.     {
  72.       Point3dCollection grips = null;
  73.       string key = GetKey(e);
  74.       if (_gripDict.ContainsKey(key))
  75.       {
  76.         grips = _gripDict[key];
  77.       }
  78.       return grips;
  79.     }
  81.     public override void GetGripPoints(
  82.       Entity e,
  83.       Point3dCollection grips,
  84.       IntegerCollection snaps,
  85.       IntegerCollection geomIds
  86.     )
  87.     {
  88.       base.GetGripPoints(e, grips, snaps, geomIds);
  90.       StoreGripInfo(e, grips);
  91.     }
  93.     public override void MoveGripPointsAt(
  94.       Entity e,
  95.       IntegerCollection indices,
  96.       Vector3d offset
  97.     )
  98.     {
  99.       Document doc =
  100.         Application.DocumentManager.MdiActiveDocument;
  101.       Editor ed = doc.Editor;
  103.       Point3dCollection grips = RetrieveGripInfo(e);
  104.       if (grips != null)
  105.       {
  106.         // Could get multiple points moved at once,
  107.         // hence the integer collection
  109.         foreach (int i in indices)
  110.         {
  111.           // Get the grip point from our internal state
  113.           Point3d pt = grips[i];
  115.           // Draw a vector from the grip point to the newly
  116.           // offset location, using the index into the
  117.           // grip array as the color (excluding colours 0 and 7).
  119.           // These vectors don't getting cleared, which makes
  120.           // for a fun effect.
  122.           ed.DrawVector(
  123.             pt,
  124.             pt + offset,
  125.             (i >= 6 ? i + 2 : i + 1), // exclude colours 0 and 7
  126.             false
  127.           );
  128.         }
  129.       }
  130.       base.MoveGripPointsAt(e, indices, offset);
  131.     }
  133.     [CommandMethod("GOO")]
  134.     public void GripOverruleOnOff()
  135.     {
  136.       Document doc =
  137.         Application.DocumentManager.MdiActiveDocument;
  138.       Editor ed = doc.Editor;
  140.       if (overruling)
  141.       {
  142.         ObjectOverrule.RemoveOverrule(
  143.           RXClass.GetClass(typeof(Entity)),
  144.           GripVectorOverrule.theOverrule
  145.         );
  146.       }
  147.       else
  148.       {
  149.         ObjectOverrule.AddOverrule(
  150.           RXClass.GetClass(typeof(Entity)),
  151.           GripVectorOverrule.theOverrule,
  152.           true
  153.         );
  154.       }
  155.       overruling = !overruling;
  156.       GripOverrule.Overruling = overruling;
  158.       ed.WriteMessage(
  159.         "\nGrip overruling turned {0}.",
  160.         (overruling ? "on" : "off")
  161.       );
  162.     }
  163.   }
  164. }
One important thing to bear in mind about this sample: we have to store the grips for a particular entity during the GetGripPointsAt() call and then use them during the MoveGripPointsAt() call. This is complicated for a number of reasons...
Firstly, we can’t just store the points in a single point collection, as there could be multiple calls to GetGripPointsAt() (while the grips are retrieved and displayed by AutoCAD) followed by multiple calls to MoveGripPointsAt() (while the grips are used to manipulate the objects). So we really need to map a set of points to a particular object.
The really tricky thing is that we have an entity passed into both GetGripPointsAt() and MoveGripPointsAt(), but – and here’s the rub – the GetGripPointsAt() entity is typically the original, database-dependent entity, while the entities passed into MoveGripPointsAt() are temporary clones. The temporary clones do not have ObjectIds, which is the best way to identify objects and associate data with them in a map (for instance).
The default cloning behaviour can be overruled using a TransformOverrule – by returning false from the CloneMeForDragging() callback – but assuming we don’t do that (and we don’t really want to do that, as it opens another can of worms), we need to find another way to identify an object that is passed into GetGripPointsAt() with its clone passed in to MoveGripPointsAt().
The solution I ended up going for was to generate a key based on the class-name of the object followed by its geometric extents. This isn’t perfect, but it’s as good as I could find. There is a possibility that entities of the same type could exist at the same spot and still have different grips (which is the main problem – if they have the same grip locations then it doesn’t matter), but that will cause problems with this implementation. If people want to implement a more robust technique, they will probably need to do so for specific entity types, where they have access to more specific information that will help identify their objects: we are sticking to generic entity-level information, which makes it a little hard to be 100% certain we have the right object.
One other point… as we’re using the geometric extents to identify an object, it’s hard to clear the grip information from our dictionary: by the time the OnGripStatusChanged() method is called, the entity’s geometry has typically changed, which means we can no longer find it in the dictionary. So for a cleaner solution it’s worth clearing the dictionary at an appropriate moment (probably using some kind of command- or document locking-event).
OK, now let’s see what happens when we NETLOAD our application and run our GOO command, which toggles the use of the grip overrule:
Command: GOO
Grip overruling turned on.
OK, so far so good. Let’s create a standard AutoCAD polyline containing both line and arc segments:

When we select it, we see its grips along with the quick properties panel:

And when we use its various grips, we see temporary vectors drawn during each MoveGripPointsAt() call (which will disappear at the next REGEN):

Fun stuff! I’m looking forward to diving further into Overrules over the next week or two… :-)

本帖子中包含更多资源

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

x
回复 支持 反对

使用道具 举报

雪山飞狐_lzh
 楼主| 发表于 2009-9-7 12:03 | 显示全部楼层
七、简单的改变直线显示
August 17, 2009
A simple overrule to change the way AutoCAD lines are displayed using .NET
Thanks to Stephen Preston, who manages our DevTech Americas team, for donating the samples from his upcoming AU class for posting on this blog.
Let’s start the week with a nice simple sample: the first from Stephen’s AU class. Looking back even to the first C# overrule sample I posted here, I can see that most have been quite complex, mainly because they’ve performed complicated things. Today’s code implements a very simple DrawableOverrule which changes the way lines are displayed in AutoCAD:
Here’s Stephen’s C# code, reformatted to fit the blog:
  2. using Autodesk.AutoCAD.Runtime;
  3. using Autodesk.AutoCAD.ApplicationServices;
  4. using Autodesk.AutoCAD.DatabaseServices;
  5. using Autodesk.AutoCAD.GraphicsInterface;
  7. namespace MyFirstOverrule
  8. {
  9.   // This is our custom DrawableOverrule class.
  10.   // In this case we're just overruling WorldDraw
  12.   public class MyDrawOverrule : DrawableOverrule
  13.   {
  14.     public override bool WorldDraw(Drawable drawable, WorldDraw wd)
  15.     {
  16.       // Cast Drawable to Line so we can access its methods and
  17.       // properties
  18.       Line ln = (Line)drawable;
  20.       // Draw some graphics primitives
  21.       wd.Geometry.Circle(
  22.         ln.StartPoint + 0.5 * ln.Delta,
  23.         ln.Length / 5,
  24.         ln.Normal
  25.       );
  27.       // In this case we don't want the line to draw itself, nor do
  28.       // we want ViewportDraw called
  29.       return true;
  30.     }
  31.   }
  33.   public class Commands
  34.   {
  35.     //Shared member variable to store our Overrule instance
  36.     private static MyDrawOverrule _drawOverrule;
  38.     [CommandMethod("TOG")]
  39.     public static void ToggleOverrule()
  40.     {
  41.       // Initialize Overrule if first time run
  43.       if (_drawOverrule == null)
  44.       {
  45.         _drawOverrule = new MyDrawOverrule();
  46.         Overrule.AddOverrule(
  47.           RXObject.GetClass(
  48.             typeof(Line)),
  49.             _drawOverrule,
  50.             false
  51.           );
  52.         Overrule.Overruling = true;
  53.       }
  54.       else
  55.       {
  56.         // Toggle Overruling on/off
  57.         Overrule.Overruling = !Overrule.Overruling;
  58.       }
  60.       // Regen is required to update changes on screen
  61.       Application.DocumentManager.MdiActiveDocument.Editor.Regen();
  62.     }
  63.   }
  64. }
Some points to note:
    * This code chooses to replace the way lines are currently drawn
          o Rather than drawing a line, we draw a circles at the line’s mid-point with a radius relative to the line’s length
    * We’ve deliberately kept the code very simple: a single command (TOG) is used to toggle the use of the overrule
    * Rather than always relying on toggling the overall Overruling state, we force it to true when we run for the first time
          o I have another application loaded that implements overrules: the first time the TOG command was run previously, overruling was actually turned off if we don’t do it this way
To try the code, build the application against AutoCAD 2010 (or even higher, if you’re visiting us from the future :-) and draw some lines:

Now let’s NETLOAD our application and run the TOG command:

Each line has been “replaced” by a circle. But when we select one of the circles, we see it’s really just a line, and shows the grips a line would:

When we grip-edit an end-point of one of our lines, we can see it changing the line, but the graphics displayed continue to be circular:

And finally, if we finish the editing operation and run the TOG command again we see the lines has been modified:

That’s it for today’s post. I’ll probably be delving further into Stephen’s material for posts later in the week.


本帖子中包含更多资源

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

x
回复 支持 反对

使用道具 举报

雪山飞狐_lzh
 楼主| 发表于 2009-9-12 20:17 | 显示全部楼层
八、把点附着到曲线
August 24, 2009
Gluing a point to an AutoCAD curve using overrules from .NET – Part 1
Over the weekend I put together a little prototype to prove a concept for an internal project I’m working on. The idea was to force a point onto a curve (meaning anything inheriting from Curve in AutoCAD, such as Arc, Circle, Ellipse, Leader, Line, Polyline, Polyline2d, Polyline3d, Ray, Spline, Xline…), so that when the point is moved it snaps onto the curve to which it’s assigned. The solution I’ve put together is far from being complete – which is partly why I’m planning on making this a series, so I can flesh it out a little further in further posts – but it does demonstrate a reasonable technique for addressing the requirement.
The approach I chose was to use a TransformOverrule to modify the standard AutoCAD point’s TransformBy() behaviour (see this previous post for some commentary on using a TransformOverrule vs. a GripOverrule). Our TransformOverrule stores a list of curves that have had points attached to them, and during TransformBy() we check each one to see which curve this point was on. We then get the transformed point (i.e. the one being chosen by the user) and from there we get the closest point on that curve, which becomes the point’s new location.
TransformBy() is a pretty handy operation to overrule: it’s used by grip-editing and by the MOVE command, so you know these operations will lead to your object’s positional integrity being maintained (direct modification of properties, such as via the Properties Palette, won’t lead to it being called, however, so it’s not enough if you need to maintain complete control).
Some comments on the choice of storing a list of curves rather than some other association between the point and the curve:
    * Storing a map between the point (via its ObjectId) and the curve wouldn’t work, as TransformBy() often has to work on a temporary copy of an object, rather than the object itself (and the copy’s ObjectId will therefore be Null).
          o We might also have looked at an approach such as the one used previously in our GripOverrule.
    * It might be possible to attach data (perhaps XData) to the point identifying the curve it’s attached to, but this would need to be available on the temporary clone (and is something that I’d need to check works).
    * It’s possible that working through a list of curves, checking each one, could become perceptibly slow if working with huge sets of data, but at that point a more efficient spatial indexing technique could be adopted.
    * Using a list of curves also allows us to modify the implementation to allow a point to travel along a network of curves (we’ll go through this modification in a future post).
    * One drawback of this approach is that once we move the curve independently from the point, they become detached as the point is no longer on any of the curves. We’ve put a specific clause in to allow points not on curves to be moved, but it would also be good to have the point be transformed along with the curve, so they stay together (another potential future modification). In the meantime the user will have to move the point back onto the curve (using the NEAr object snap, to make sure it’s precise) for the overrule to work for it, again.
One last point: we’re not persisting the curve list, in any way, so don’t expect points to reattach to lines when a session is restarted (until the POC command is used to create further points on curves and therefore add the curves to the list of those being managed by our system).
OK, enough blather, let’s get on with looking at 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 PointOnCurveTest
  10. {
  11.   public class PtTransOverrule : TransformOverrule
  12.   {
  13.     // A static pointer to our overrule instance
  15.     static public PtTransOverrule theOverrule =
  16.       new PtTransOverrule();
  18.     // A list of the curves that have had points
  19.     // attached to
  21.     static internal List<ObjectId> _curves =
  22.       new List<ObjectId>();
  24.     // A flag to indicate whether we're overruling
  26.     static bool overruling = false;
  28.     public PtTransOverrule() {}
  30.     // Out primary overruled function
  32.     public override void TransformBy(Entity e, Matrix3d mat)
  33.     {
  34.       // We only care about points
  36.       DBPoint pt = e as DBPoint;
  37.       if (pt != null)
  38.       {
  39.         Database db = HostApplicationServices.WorkingDatabase;
  41.         // For each curve, let's check whether our point is on it
  43.         bool found = false;
  45.         // We're using an Open/Close transaction, to avoid problems
  46.         // with us using transactions in an event handler
  48.         OpenCloseTransaction tr =
  49.           db.TransactionManager.StartOpenCloseTransaction();
  50.         using (tr)
  51.         {
  52.           foreach (ObjectId curId in _curves)
  53.           {
  54.             DBObject obj = tr.GetObject(curId, OpenMode.ForRead);
  55.             Curve cur = obj as Curve;
  56.             if (cur != null)
  57.             {
  58.               Point3d ptOnCurve =
  59.                 cur.GetClosestPointTo(pt.Position, false);
  60.               Vector3d dist = ptOnCurve - pt.Position;
  61.               if (dist.IsZeroLength(Tolerance.Global))
  62.               {
  63.                 Point3d pos =
  64.                   cur.GetClosestPointTo(
  65.                     pt.Position.TransformBy(mat),
  66.                     false
  67.                   );
  68.                 pt.Position = pos;
  69.                 found = true;
  70.                 break;
  71.               }
  72.             }
  73.           }
  74.           // If the point isn't on any curve, let the standard
  75.           // TransformBy() do its thing
  77.           if (!found)
  78.           {
  79.             base.TransformBy(e, mat);
  80.           }
  81.         }
  82.       }
  83.     }
  85.     [CommandMethod("POC")]
  86.     public void CreatePointOnCurve()
  87.     {
  88.       Document doc =
  89.         Application.DocumentManager.MdiActiveDocument;
  90.       Database db = doc.Database;
  91.       Editor ed = doc.Editor;
  93.       // Ask the user to select a curve
  95.       PromptEntityOptions opts =
  96.         new PromptEntityOptions(
  97.           "\nSelect curve at the point to create: "
  98.         );
  99.       opts.SetRejectMessage(
  100.         "\nEntity must be a curve."
  101.       );
  102.       opts.AddAllowedClass(typeof(Curve), false);
  104.       PromptEntityResult per = ed.GetEntity(opts);
  106.       ObjectId curId = per.ObjectId;
  107.       if (curId != ObjectId.Null)
  108.       {
  109.         // Let's make sure we'll be able to see our point
  111.         db.Pdmode = 97;  // square with a circle
  112.         db.Pdsize = -10; // relative to the viewport size
  114.         Transaction tr =
  115.           doc.TransactionManager.StartTransaction();
  116.         using (tr)
  117.         {
  118.           DBObject obj =
  119.             tr.GetObject(curId, OpenMode.ForRead);
  120.           Curve cur = obj as Curve;
  121.           if (cur != null)
  122.           {
  123.             // Out initial point should be the closest point
  124.             // on the curve to the one picked
  126.             Point3d pos =
  127.               cur.GetClosestPointTo(per.PickedPoint, false);
  128.             DBPoint pt = new DBPoint(pos);
  130.             // Add it to the same space as the curve
  132.             BlockTableRecord btr =
  133.               (BlockTableRecord)tr.GetObject(
  134.                 cur.BlockId,
  135.                 OpenMode.ForWrite
  136.               );
  137.             ObjectId ptId = btr.AppendEntity(pt);
  138.             tr.AddNewlyCreatedDBObject(pt, true);
  139.           }
  140.           tr.Commit();
  142.           // And add the curve to our central list
  144.           _curves.Add(curId);
  145.         }
  147.         // Turn on the transform overrule if it isn't already
  149.         if (!overruling)
  150.         {
  151.           ObjectOverrule.AddOverrule(
  152.             RXClass.GetClass(typeof(DBPoint)),
  153.             PtTransOverrule.theOverrule,
  154.             true
  155.           );
  156.           overruling = true;
  157.           TransformOverrule.Overruling = true;
  158.         }
  159.       }
  160.     }
  161.   }
  162. }
Now let’s see what happens when we run the POC command (for Point On Curve, but then it’s also a Proof Of Concept – geddit? :-).
The POC command will create a point at the selected location on a curve, at which point we can grip-edit it:

We can see that as we move the grip point around the drawing, the closest point to the attached curve is always used:

The point is always on the original curve, even if we try to select a point on another curve (even one that may be on the list of curves maintained by our PtTransOverrule class, if the POC command has been used on other curves):

That’s enough to get us started. Later in the week we’ll look at extending the code to create a stronger attachment between the point and the curve, but also to allow the point to travel along a network of curves. Fun, fun, fun! :-)

本帖子中包含更多资源

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

x
回复 支持 反对

使用道具 举报

雪山飞狐_lzh
 楼主| 发表于 2009-9-12 20:20 | 显示全部楼层
August 26, 2009
Gluing a point to an AutoCAD curve using overrules from .NET – Part 2
In the last post we looked at some code to create a point on a curve, and make sure it stays on that curve when edited.
In this post we’re extending that code (albeit slightly) to work with a network of curves: the idea is that any curve which has a point created on it becomes a candidate for any point to snap onto as it moves around. This could clearly be extended to provided a better way of specifying the curves forming the network, of course.
Here’s the updated C# code
  2. sing 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;
  8. namespace PointOnCurveTest
  9. {
  10.   public class PtTransOverrule : TransformOverrule
  11.   {
  12.     // A static pointer to our overrule instance
  13.     static public PtTransOverrule theOverrule =
  14.       new PtTransOverrule();
  15.     // A list of the curves that have had points
  16.     // attached to
  17.     static internal List<ObjectId> _curves =
  18.       new List<ObjectId>();
  19.     // A flag to indicate whether we're overruling
  20.     static bool overruling = false;
  21.     public PtTransOverrule() {}
  22.     // Out primary overruled function
  23.     public override void TransformBy(Entity e, Matrix3d mat)
  24.     {
  25.       // We only care about points
  26.       DBPoint pt = e as DBPoint;
  27.       if (pt != null)
  28.       {
  29.         Database db = HostApplicationServices.WorkingDatabase;
  30.         // Work through the curves to find the closest to our
  31.         // transformed point
  32.         double min = 0.0;
  33.         Point3d bestPt = Point3d.Origin;
  34.         bool first = true;
  35.         // We're using an Open/Close transaction, to avoid
  36.         // problems with us using transactions in an event
  37.         // handler
  38.         OpenCloseTransaction tr =
  39.           db.TransactionManager.StartOpenCloseTransaction();
  40.         using (tr)
  41.         {
  42.           foreach (ObjectId curId in _curves)
  43.           {
  44.             DBObject obj =
  45.               tr.GetObject(curId, OpenMode.ForRead);
  46.             Curve cur = obj as Curve;
  47.             if (cur != null)
  48.             {
  49.               Point3d ptLoc =
  50.                 pt.Position.TransformBy(mat);
  51.               Point3d ptOnCurve =
  52.                 cur.GetClosestPointTo(ptLoc, false);
  53.               Vector3d dist = ptOnCurve - ptLoc;
  54.               if (first || dist.Length < min)
  55.               {
  56.                 first = false;
  57.                 min = dist.Length;
  58.                 bestPt = ptOnCurve;
  59.               }
  60.             }
  61.           }
  62.           pt.Position = bestPt;
  63.         }
  64.       }
  65.     }
  66.     [CommandMethod("POC")]
  67.     public void CreatePointOnCurve()
  68.     {
  69.       Document doc =
  70.         Application.DocumentManager.MdiActiveDocument;
  71.       Database db = doc.Database;
  72.       Editor ed = doc.Editor;
  73.     // Ask the user to select a curve
  74.       PromptEntityOptions opts =
  75.       new PromptEntityOptions(
  76.         "\nSelect curve at the point to create: "
  77.       );
  78.       opts.SetRejectMessage(
  79.         "\nEntity must be a curve."
  80.       );
  81.       opts.AddAllowedClass(typeof(Curve), false);
  82.       PromptEntityResult per = ed.GetEntity(opts);
  83.    
  84.       ObjectId curId = per.ObjectId;
  85.       if (curId != ObjectId.Null)
  86.       {
  87.       // Let's make sure we'll be able to see our point
  88.       db.Pdmode = 97;  // square with a circle
  89.       db.Pdsize = -10; // relative to the viewport size
  90.         Transaction tr =
  91.           doc.TransactionManager.StartTransaction();
  92.         using (tr)
  93.         {
  94.           DBObject obj =
  95.             tr.GetObject(curId, OpenMode.ForRead);
  96.           Curve cur = obj as Curve;
  97.           if (cur != null)
  98.           {
  99.           // Our initial point should be the closest point
  100.           // on the curve to the one picked
  101.             Point3d pos =
  102.               cur.GetClosestPointTo(per.PickedPoint, false);
  103.             DBPoint pt = new DBPoint(pos);
  104.           // Add it to the same space as the curve
  105.             BlockTableRecord btr =
  106.               (BlockTableRecord)tr.GetObject(
  107.                 cur.BlockId,
  108.                 OpenMode.ForWrite
  109.               );
  110.             ObjectId ptId = btr.AppendEntity(pt);
  111.             tr.AddNewlyCreatedDBObject(pt, true);
  112.           }
  113.           tr.Commit();
  114.         
  115.         // And add the curve to our central list
  116.         
  117.           _curves.Add(curId);
  118.         }
  119.       // Turn on the transform overrule if it isn't already
  120.         if (!overruling)
  121.         {
  122.           ObjectOverrule.AddOverrule(
  123.             RXClass.GetClass(typeof(DBPoint)),
  124.           PtTransOverrule.theOverrule,
  125.             true
  126.           );
  127.           overruling = true;
  128.           TransformOverrule.Overruling = true;
  129.         }
  130.       }
  131.     }
  132.   }
  133. }
Now after having run our POC command to add points to a number of curves – effectively adding them to the “network” – we can grip-move a point, and should another curve in the network be closer, the point being edited will snap across to that one:

本帖子中包含更多资源

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

x
回复 支持 反对

使用道具 举报

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

本版积分规则

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

GMT+8, 2024-4-23 14:56 , Processed in 0.249173 second(s), 24 queries , Gzip On.

Powered by Discuz! X3.4

Copyright © 2001-2021, Tencent Cloud.

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