AutoCAD DevBlog

Get and set layer and entity transparency using LISP

By Adam Nagy

Why doesn't the following code work? vla-get-transparency highlights as blue in the VLIDE, but I get this error:

"Error: ActiveX Server returned the error: unknown name: Transparency"

(setq ENT (entsel))

(if ENT

  (progn

    (setq VLA_OBJ_NAME (vlax-ename->vla-object (car ENT))

    VLA_OBJ_LAYER (vla-get-layer VLA_OBJ_NAME)

    VLA_ACT_DOC (vla-get-ActiveDocument (vlax-get-Acad-Object))

    LAYERNAME (vla-Item (vla-get-Layers VLA_ACT_DOC) VLA_OBJ_LAYER)

    )

    (if (>= (atof (substr (getvar "acadver") 1 4)) 18.1)

      (setq PROPTRAN (vla-get-transparency LAYERNAME))

    )

  )

)

Solution

The properties that you access when using the COM helpers of LISP are based on the ActiveX API.

If you look for the Transparency property in the ActiveX API, then you’ll find that it is only available for AcadRasterImage and AcadWipeout entities.

The Transparency for entities (which is only available in AutoCAD 2011) is provided by new interfaces like IAcadEntity2 and they are called EntityTransparency.

In case of layers however, there is no property like that.

That transparency value can be calculated from the layer’s XData. If it’s not there, then it’s the default 0%

; gets transparency in percentage 
(defun getLayerTransparency (layerName / layer transparency) 
  (setq layer (tblobjname "LAYER" layerName)) 
  ; get the XData of AcCmTransparency    
  (setq transparency (cdr (assoc 1071 (cdar (cdr (assoc -3 
    (entget layer '("AcCmTransparency")))))))) 
  (if (= transparency nil) 
    ; if we did not get a value it must be the default 0% 
    (setq transparency 0) 
    ; if we got a value then calculate from it 
    (progn 
      ; get the lower byte of the value 0..255 
      ; (100%..0% in the AutoCAD user interface) 
      (setq transparency (lsh (lsh transparency 24) -24)) 
      ; convert the value to a percentage 
      (setq transparency (fix (- 100 (/ transparency 2.55))))    
    ) ; (progn 
  ) ; (if  
)

(defun c:testGet (/ ent layerName transparency) 
  (setq ent (car (entsel))) 
  (setq layerName (cdr (assoc 8 (entget ent))))
  (setq transparency (getLayerTransparency layerName)) 
  (princ transparency) 
  (princ) 
)

It does not seem possible to set the value the same way - by adjusting the XData value -, but you can use the _LAYER command for that:

(defun c:testSet (/ ent layerName transparency) 
  (setq ent (car (entsel))) 
  (setq transparency (getint "Transparency value")) 
  (setq layerName (cdr (assoc 8 (entget ent))))
  (command "_LAYER" "_TR" transparency layerName "") 
  (princ) 
)

Code has been updated based on BlackBox's comments. Now it is not using unnecessary ActiveX function calls.

Announcement: AutoCAD® 2014 debug symbols now available on the public server

By Gopinath Taget

The Autodesk Public Symbol Server (http://symbols.autodesk.com) now contains the symbol files for AutoCAD® 2014. If you are not familiar with AutoCAD symbols or the public symbol server, this blog post by Kean might help.

Happy Debugging!

Linking attributes and table using DataExtraction API

By Balaji Ramamoorthy

The "EATTEXT" command in AutoCAD can extract data such as attribute text and display it inside a table. Here is a sample code to do it programmatically using the DataExtraction API and to create a table that links with the data.

To try this,

1) Copy the attached "MyBlock.dwg" to "C:\Temp" folder.

2) Start AutoCAD and open the drawing

3) Run the command and select a point when prompted for the insertion point of the table.

4) Change the attribute values to a different value

5) Right-click on the table and select "Update Table Data Links" option to refresh the values.

// Add the AcDx.dll reference from the inc folder

using Autodesk.AutoCAD.DataExtraction;

 

Document doc = Application.DocumentManager.MdiActiveDocument;

Editor ed = doc.Editor;

Database db = doc.Database;

 

// Copy the attached "MyBlock.dwg" to C:\Temp for testing

// The Dxe file will be created at runtime in C:\Temp if not found

const string dxePath = @"C:\Temp\MyData.dxe";

const string dwgFolder = @"C:\Temp\";

const string dwgName = "MyBlock.dwg";

 

if (System.IO.File.Exists(dxePath) == false)

{

    // Create the DXE file with the information that we want to extract

    DxExtractionSettings setting = new DxExtractionSettings();

 

    IDxFileReference dxFileReference

        = new DxFileReference(dwgFolder, dwgFolder + dwgName);

 

    setting.DrawingDataExtractor.Settings.DrawingList.AddFile

                                            (dxFileReference);

 

    setting.DrawingDataExtractor.DiscoverTypesAndProperties

                                        (dwgFolder + dwgName);

 

    List<IDxTypeDescriptor> types

        = setting.DrawingDataExtractor.DiscoveredTypesAndProperties;

 

    List<string> selectedTypes = new List<string>();

    List<string> selectedProps = new List<string>();

    foreach (IDxTypeDescriptor td in types)

    {

        if (td.GlobalName.Equals("BlockReferenceTypeDescriptor.Test"))

            selectedTypes.Add(td.GlobalName);

 

        foreach (IDxPropertyDescriptor pd in td.Properties)

        {

            if (pd.GlobalName.Equals("AcDxObjectTypeGlobalName") ||

                pd.GlobalName.Equals("AcDxObjectTypeName") ||

                pd.GlobalName.Equals("BlockReferenceAttribute.NAME") ||

                pd.GlobalName.Equals("BlockReferenceAttribute.PLACE"))

            {

                if (!selectedProps.Contains(pd.GlobalName))

                    selectedProps.Add(pd.GlobalName);

            }

        }

    }

 

    setting.DrawingDataExtractor.Settings.ExtractFlags

                    = ExtractFlags.Nested | ExtractFlags.Xref;

 

    setting.DrawingDataExtractor.Settings.SetSelectedTypesAndProperties

                        (types, selectedTypes, selectedProps);

 

    setting.OutputSettings.DataCellStyle = "Data";

    setting.OutputSettings.FileOutputType = AdoOutput.OutputType.xml;

    setting.OutputSettings.HeaderCellStyle = "Header";

    setting.OutputSettings.ManuallySetupTable = true;

    setting.OutputSettings.OuputFlags = DxOuputFlags.Table;

    setting.OutputSettings.TableStyleId = db.Tablestyle;

    setting.OutputSettings.TableStyleName = "Standard";

    setting.OutputSettings.TitleCellStyle = "Title";

    setting.OutputSettings.UsePropertyNameAsColumnHeader = false;

 

    setting.Save(dxePath);

}

 

//Create a DataLink

ObjectId dlId = ObjectId.Null;

DataLinkManager dlm = db.DataLinkManager;

using (DataLink dl = new DataLink())

{

    String dataLinkName = "MyDataLink2";

    dlId = dlm.GetDataLink(dataLinkName);

 

    if(dlId.IsNull)

    {

        // create a datalink

        dl.ConnectionString = dxePath;

        dl.ToolTip = "My Data Link";

        dl.Name = dataLinkName;

 

        DataAdapter da

            = DataAdapterManager.GetDataAdapter

            ("Autodesk.AutoCAD.DataExtraction.DxDataLinkAdapter");

 

        if (da != null)

            dl.DataAdapterId = da.DataAdapterId;

        dlId = dlm.AddDataLink(dl);

    }

}

 

// Ask for the table insertion point

PromptPointResult pr = ed.GetPoint("\nEnter table insertion point: ");

if (pr.Status != PromptStatus.OK)

    return;

 

// Create a table

ObjectId tableId = ObjectId.Null;

using (Transaction tr = db.TransactionManager.StartTransaction())

{

    Table table = new Table();

 

    // 2 rows and 4 columns

    table.SetSize(2, 4);

 

    table.Position = pr.Value;

 

    //Add the Table to the drawing database

    BlockTable bt = tr.GetObject(

                                    db.BlockTableId,

                                    OpenMode.ForWrite

                                ) as BlockTable;

 

    BlockTableRecord btr = tr.GetObject

                            (

                                bt[BlockTableRecord.ModelSpace],

                                OpenMode.ForWrite

                            ) as BlockTableRecord;

 

    tableId = btr.AppendEntity(table);

    tr.AddNewlyCreatedDBObject(table, true);

 

    //table.Cells.SetDataLink(dlId, false);

    table.SetDataLink(1, 0, dlId, true);

 

    //Generate the layout

    table.GenerateLayout();

 

    tr.Commit();

}

Download MyBlock

Autoloader Example for invoking a Startup Command in AutoCAD

by Fenton Webb

 

Initializing AutoCAD UI from within your .NET Initialize() is not advised. The reason is that your .NET DDL may be loaded on AutoCAD startup, and at the point Initialize for your App is called certain subsystems inside of AutoCAD have not properly initialized – e.g. Ribbon, COM, Palettes, etc.

The normal solution is to create a document event reactor inside of your Initialize() and watch for a new document created, then from within there create another event reactor which watches for AutoCAD entering Quiescent state, then, from within that function callback do your initialize.

Using the Autoloader, all of this is handled for your automatically, simply use the Commands::Command.StartupCommand attribute to indicate your startup/initialize command. e.g.

<?xml version="1.0" encoding="utf-8"?>

<ApplicationPackage SchemaVersion="1.0" AutodeskProduct="AutoCAD" Name="MyTestApp" Description="FentyCAD demo app" AppVersion="1.0.0" FriendlyVersion="1.0.0" ProductType="Application" SupportedLocales="Enu" AppNameSpace="appstore.exchange.autodesk.com" Author="Fenton Webb" ProductCode="{17FFEEB3-D653-491D-97D3-40FC069FB967}" UpgradeCode="{1F07C18D-E5D9-4775-9A80-3E240CB4D1C3}">

  <RuntimeRequirements OS="Win32|Win64" Platform="AutoCAD|AutoCAD*" SeriesMin="R19.0" SeriesMax="R19.1" />

  <CompanyDetails Name="FentyCAD" Url="www.FentyCAD.com" Email="[email protected]" />

  <Components Description="Any CPU DLLs">

    <RuntimeRequirements OS="Win32|Win64" Platform="AutoCAD|AutoCAD*" SeriesMin="R19.0" SeriesMax="R19.1" />

    <ComponentEntry AppName="FentiCADMain" Version="1.0.0" ModuleName="./Contents/Windows/MyApp.dll" AppDescription="Main App .NET DLL" LoadOnCommandInvocation="True">

      <Commands GroupName="FentyCAD_MAIN">

        <Command Local="_FCStartup" Global="FCStartup" Description="Startup command used to initialize my app" StartupCommand="True" />

      </Commands>

    </ComponentEntry>

  </Components>

</ApplicationPackage>

Some Tips on AutoCAD OEM

by Fenton Webb

Just some small for new users of AutoCAD OEM…

1) When you install OEM on your system, you install two things - the Toolkit (OemMakeWizard and OemInstallerWizard) and a runnable application called AutoCAD OEM.

2) AutoCAD OEM is a relaxed version of any OEM product you build with the OemMakeWizard. It is used to test OEM specific stuff you are doing, it allows NETLOAD, Appload and the VBAIDE (if VBA is installed)...

3) The modules you add to OEM are usually just your modules and direct dependencies – basically the ones that you load into normal AutoCAD, and the ones that your App relies on (excluding standard runtime modules).

4) DLLs that you include *must* be built with the OEM ObjectARX SDK because OEM modules are dependent on aoem.exe not acad.exe like in the normal ObejctARX SDK. If you try to load modules built with the normal ObjectARX SDK they will not load because they are being physically loaded into the wrong host exe.

5) When you rebuild your app DLLs, you must rebuild your OEM product in order to test them - basically, your application DLLs must be restamped and aligned with your OEM product.

6) In order for your application to load properly, you must have a unique Logical Name in Your Modules declaration page of the OemMakeWizard.

Folder structure for Autoloader Bundles using Revit as an Example

by Fenton Webb

If you are posting an App to the Exchange store, posting your files as an unorganized zip will delay posting of your App. 

Here’s a quick tutorial on how to lay your app bundle out before posting to the Exchange store.

First of all, you need to understand what the bundle folder structure is all about.

1. The bundle App folder structure is a Windows and Mac solution for deploying Autodesk plugins. AutoCAD also comes as a Mac product, we also have various cloud an mobile products like AutoCAD WS that are/will be using the bundle format.
2. The bundle App folder structure supports multiple versions in the same bundle, this is intended for ease of deployment and for a clean user experience. It’s true that all versions of your App will be installed, even if the user doesn’t have the supporting version on his system so there is some waste; because of this you have to make sure you carefully lay out your bundle to share resources.
3. The bundle App folder structure allows for multiple Autodesk product support in the same bundle. This is particularly useful if you have a main application plugin that has extensions. For instance, say you have a Revit room designer main app with export/import functions that link to AutoCAD.

Here are some bundle folder layout recommendations for creating various App bundles… You can add as many folders as you like, but your App must be self contained.

Revit App Bundle Folder Example

• The Resources folder is intended to to store your application help files, icons, any shared resources that your application has.
• Win32 is intended to house all of your Windows 32bit specific runtime. If your application is platform independent, then there’s no need to have a Win32 folder, simply use the Windows folder.
• Win64 is intended to house all of your Windows 64bit specific runtime. If your application is platform independent, then there’s no need to have a Win64 folder, simply use the Windows folder.
• The Windows folder is intended to house all platform independent runtime. If you have platform specific runtime, then use either the Win32 or Win64 folders.
• The R2013 and R2014 folders are Revit specific version folders. These folders are intended to house version specific runtime, for example Revit 2013 runtime for Win32 goes in the Win32\R2013 folder. If you have shared DLL components for both 2013 and 2014, say a licensing.dll then you can simply suffix the Revit version on your DLL name e.g. MyRevitApp2013.dll and MyRevitApp2014.dll then just house all 3 DLLs in the specific platform folder (Win32/Win64 or Windows)

Revit App Bundle Example with AutoCAD Extensions

AutoCAD uses a different series versioning system than Revit. AutoCAD generally has binary compatibility between series, however it does normally break every 3 releases. If you want to include AutoCAD extensions to your Revit product, here’s how you would lay out your bundle. (Notice I have omitted R19.1 AutoCAD 2014, that’s because R19.1 is binary compatible with R19.0)

Submit your Apps to Exchange using this format, and your Apps with be processed quicker.

Find which properties changed on modified event

By Augusto Goncalves

This is common request: identify what have changed on Modified event of entities. In fact this feature is not available on the API, mainly because it can potentially represent a big use of memory. But a (partial) workaround may help in some cases!

The main thing is that is not easy to track everything that change on a entity, mainly because one can refer to another, or even contain internal data not easily exposed. Also, in complex scenarios like this, a generic approach may not capture everything.

So I decided to do a quick try with .NET properties, basically using reflection mechanism to store the data and compare back. Below is a common code that track changes with Modified event, but it has a few extra lines (marked in yellow) enabled by .NET Extension mechanism.

[CommandMethod("monitorEntity")]

public void CmdMonitorEntity()

{

  // select an entity

  Editor ed = Application.DocumentManager.

    MdiActiveDocument.Editor;

  PromptEntityResult resEnt = ed.GetEntity(

    "Select an entity: ");

  if (resEnt.Status != PromptStatus.OK) return;

 

  // and register the event

  MonitorEntity(resEnt.ObjectId);

}

private void MonitorEntity(ObjectId objectId)

{

  Database db = Application.DocumentManager.

    MdiActiveDocument.Database;

  using (Transaction trans = db.

    TransactionManager.StartTransaction())

  {

    Entity ent = trans.GetObject(objectId,

      OpenMode.ForRead) as Entity;

 

    // start the monitor this object

    ent.MonitorPropertyChanges();

 

    // as usual, register for 'Modified' event

    ent.Modified += new EventHandler(ent_Modified);

  }

} 

 

void ent_Modified(object sender, EventArgs e)

{

  Entity ent = sender as Entity;

  if (ent == null) return;

 

  // list of what changed

  string[] propsModified = ent.GetModifiedProperties();

  if (propsModified.Length == 0) return;

 

  Editor ed = Application.DocumentManager.

    MdiActiveDocument.Editor;

 

  // write the values that changed

  ed.WriteMessage("\nProperties were modified:");

  foreach (string propName in propsModified)

  {

    ed.WriteMessage("\n{0}, previous value {1}",

      propName, ent.GetPreviousValue(propName));

  }

}

The code above should look very common, no extra feature other than those in yellow. As a side note, that is the beauty of .NET Extension: we can add new methods for certain types of object and the syntax is quite sharp.

At the image below, note how the properties changed are tracked after the user change the layer using the Property palette. Please test this and make sure the properties you’re tracking are listed with this mechanism. Things like nodes of a polyline will not appear.

Ok, to enable this extension methods, simply create a new class and mark as ‘static’ in C# or create as a ‘Module’ on VB.NET (where an additional metadata is required: <Extension()>).

public static class DBObjectMonitor

{

  private static Dictionary<ObjectId,

    Dictionary<string, object>> _monitorList;

 

  // list of properties for objects monitored

  private static Dictionary<ObjectId,

    Dictionary<string, object>> MonitorList

  {

    get

    {

      if (_monitorList == null) _monitorList =

        new Dictionary<ObjectId,

          Dictionary<string, object>>();

      return _monitorList;

    }

  }

 

  /// <summary>

  /// Prepare the object to monitor what have changed

  /// </summary>

  public static void MonitorPropertyChanges(this DBObject dbObj)

  {

    dbObj.OpenedForModify +=

      new EventHandler(dbObj_OpenedForModify);

  }

 

  private static void dbObj_OpenedForModify(

    object sender, EventArgs e)

  {

    StorePropeties((DBObject)sender);

  }

 

  private static void StorePropeties(DBObject dbObj)

  {

    Dictionary<string, object> objPropBefore =

      new Dictionary<string, object>();

 

    System.Reflection.PropertyInfo[] props =

      dbObj.GetType().GetProperties();

    foreach (System.Reflection.PropertyInfo prop in props)

    {

      try

      {

        // if we cannot write,

        // let's not monitor it

        if (!prop.CanWrite) continue;

 

        // save the value of the propery

        objPropBefore.Add(prop.Name,

          prop.GetValue(dbObj, null));

      }

      catch

      {

        // get the value through reflection

        // cannot be safe...

      }

    }

 

    // store all the properties based

    // on the objectId

    MonitorList.Remove(dbObj.ObjectId);

    MonitorList.Add(dbObj.ObjectId, objPropBefore);

  }

 

  /// <summary>

  /// List of properties changed on the Modified event

  /// </summary>

  public static string[]

    GetModifiedProperties(this DBObject dbObj)

  {

    // is on the list?

    if (!MonitorList.ContainsKey(dbObj.ObjectId))

      return null;

 

    // get the list of values

    Dictionary<string, object> objPropBefore =

      MonitorList[dbObj.ObjectId];

 

    // this will store the name of what was changed

    List<String> propList = new List<String>();

 

    // list of properties

    System.Reflection.PropertyInfo[] props =

        dbObj.GetType().GetProperties();

    foreach (System.Reflection.PropertyInfo prop in props)

    {

      try

      {

        // if we cannot write,

        // let's not monitor it

        if (!prop.CanWrite) continue;

 

        // save the value of the propery

        object valueBefore = objPropBefore[prop.Name];

        object valueAfter = prop.GetValue(dbObj, null);

 

        if (valueBefore.Equals(valueAfter))

          // remove from the original list

          objPropBefore.Remove(prop.Name);

        else

          propList.Add(prop.Name);

      }

      catch

      {

        // get the value through reflection

        // may not be safe...

      }

    }

 

    return propList.ToArray<string>();

  }

 

  /// <summary>

  /// Get the value for the property

  /// before this current change

  /// </summary>

  /// <param name="propertyName">

  /// Name of the property</param>

  /// <returns>The previous value</returns>

  public static object

    GetPreviousValue(

    this DBObject dbObj,

    string propertyName)

  {

    // get the list

    Dictionary<string, object> objPropBefore =

      MonitorList[dbObj.ObjectId];

 

    // this property exist?

    if (!objPropBefore.ContainsKey(propertyName))

      return null;

 

    return objPropBefore[propertyName];

  }

}

Silent install of AutoCAD OEM

by Fenton Webb

If you are trying to silently install your AutoCAD OEM maybe because it’s a prerequisite of another installer, then here’s how to do it…

setup.exe /t /q /c AOEM: INSTALLDIR="C:\Program Files\MyApp" InstallLevel=5 

In fact, that line can also be used to install any Autodesk product silently… Just substitute AOEM for the main section in the setup.ini file… e.g. AutoCAD=ACAD

Type comparison optimization in .NET

By Augusto Goncalves

Although this is not AutoCAD or Autodesk related, I always see developers doing .NET code that can be optimized. Sure in some cases this is not a concern, or the processing time that will be saved doesn’t worth the trouble. But doing some small good practices can save you big at the end of your project.

So this post is quite simple and about type comparison. The idea came from this interesting post: Drilling into .NET Runtime microbenchmarks: 'typeof' optimizations.

Basically it says that the following type comparison is the faster:

Entity ent = // initialize here

if (ent.GetType() == typeof(Line))

{

}

[Update] Comments:

As well pointed by the comments (see below), the variations of object type comparison shown here (and the linked post) will produce different results. So you need make sure which is one is the correct for each scenario. Once that is decided, I would suggest review the performance trade off of your choice at the linked post.

eInvalidInput while creating hatch with CustomDefined pattern

By Balaji Ramamoorthy

If the "SetHatchPattern" method throws an "eInvalidInput" exception while creating a hatch using a CustomDefined hatch pattern, here are few points to check.

1) Is the pattern file that defines the custom hatch pattern named correctly ? The name of the hatch pattern and the pat file name should be the same.

2) Is the folder in which the pat file is placed, added to the AutoCAD support path ?

3) Is the line breaks in the pat file ok ? The easiest way to ensure that it is ok is to take an existing custom hatch pattern file and change the definitions to suit your requirements. AutoCAD is sensitive to line breaks in the pat file and "eInvalidInput" exception because of this can be hard to spot. You can find several online resources such as this to download a custom hatch pattern file.

Here is a sample code to try out the custom hatch pattern :

Document doc = Application.DocumentManager.MdiActiveDocument;

Database db = doc.Database;

Editor ed = doc.Editor;

 

PromptResult prHatchPatternName

        = ed.GetString("\nEnter custom hatch pattern name : ");

if (prHatchPatternName.Status != PromptStatus.OK)

    return;

string patName = prHatchPatternName.StringResult;

 

PromptPointResult ppr = ed.GetPoint("Pick insertion point: ");

if (ppr.Status != PromptStatus.OK)

    return;

Point3d insertionPt = ppr.Value;

 

try

{

    using (Transaction tr = db.TransactionManager.StartTransaction())

    {

        BlockTable bt

            = tr.GetObject(db.BlockTableId, OpenMode.ForWrite) as BlockTable;

 

        BlockTableRecord btr

            = tr.GetObject( bt[BlockTableRecord.ModelSpace],

                            OpenMode.ForWrite

                          ) as BlockTableRecord;

 

        Point2d pt = new Point2d(insertionPt.X, insertionPt.Y);

 

        Polyline plBox;

        plBox = new Polyline(4);

        plBox.Normal = Vector3d.ZAxis;

        plBox.AddVertexAt(0, pt, 0.0, -1.0, -1.0);

        plBox.AddVertexAt(1, new Point2d(pt.X + 10, pt.Y), 0.0, -1.0, -1.0);

        plBox.AddVertexAt(2, new Point2d(pt.X + 10, pt.Y + 5), 0.0, -1.0, -1.0);

        plBox.AddVertexAt(3, new Point2d(pt.X, pt.Y + 5), 0.0, -1.0, -1.0);

        plBox.Closed = true;

 

        ObjectId pLineId;

        pLineId = btr.AppendEntity(plBox);

        tr.AddNewlyCreatedDBObject(plBox, true);

 

        ObjectIdCollection ObjIds = new ObjectIdCollection();

        ObjIds.Add(pLineId);

 

        Hatch hatchObj = new Hatch();

        hatchObj.SetDatabaseDefaults();

 

        Vector3d normal = new Vector3d(0.0, 0.0, 1.0);

        hatchObj.HatchObjectType = HatchObjectType.HatchObject;

        hatchObj.Color

                = Autodesk.AutoCAD.Colors.Color.FromColor(System.Drawing.Color.Blue);

        hatchObj.Normal = normal;

        hatchObj.Elevation = 0.0;

 

        hatchObj.SetHatchPattern(HatchPatternType.CustomDefined, patName);

 

        btr.AppendEntity(hatchObj);

        tr.AddNewlyCreatedDBObject(hatchObj, true);

        hatchObj.Associative = true;

        hatchObj.AppendLoop((int)HatchLoopTypes.Default, ObjIds);

        hatchObj.EvaluateHatch(true);

 

        tr.Commit();

    }

}

catch (System.Exception ex)

{

    ed.WriteMessage(ex.ToString() + Environment.NewLine);

}