Author Topic: Screw it I give up (Read 10467 times)

JohnK · « **Reply #15 on:** December 02, 2014, 12:36:38 PM »

I created a C++ project for me to start coding some of my ideas. Right now, it is a command line utility (run by double clicking .bat files) but I do plan on creating a GUI for it once I get past some of the road blocks I foresee.

So far most of what I have done is "project setup" (build files, tests, documentation, etc.). However I do have some code already though; I took some code from some other projects. As it stands now, what builds is an EXE, two DLLs and three test cases. All three tests technically fail at this point but I will let you all know when I get them working and a useful distribution.

The project is being hosted on Visual Studio Online (I plan to support building with Clang, MinGW and Visual Studio compilers) so that means the Visual Studio Project Solution will be a supplementary file (used for building with VS only) and I will be coding this the Unix way (Text editor and CMakeList files). Invites to join the project in a bit (I will need a lot of help later). I also plan on getting online builds running for this project (I really want to test this feature out).

The name of this project is: "JaSP" and it stands for (I thought this was funny): "Just a Simple Project". I choose the name because this project, for me, is getting BIG fast and it will/should be able to create a project from simple to complicated based on the `recipe' used.

Jeff H · « **Reply #16 on:** December 04, 2014, 01:14:04 PM »

Sorry default project in link of html file in first post was all screwed up and no idea what happened but updated so it already downloaded just re-download.

Jeff H · « **Reply #17 on:** December 04, 2014, 02:37:04 PM »

Here is default project to download directly

CADbloke · « **Reply #18 on:** December 07, 2014, 04:32:01 PM »

Briefly because OFF-TOPIC! html-formatted code copy is part of the Productivity Power Tools Visual Studio plugin. That plugin has lots of cool things BTW.

Jeff H · « **Reply #19 on:** August 01, 2015, 12:19:40 AM »

Database

Code - C#: [Select]

using Autodesk.AutoCAD.Runtime;
using System;
namespace Autodesk.AutoCAD.DatabaseServices
{
    public static class DatabaseExtensions
    {
        private static string standard = "Standard";
 
        public static BlockTable BlockTable(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
             return (BlockTable)trx.GetObject(db.BlockTableId, mode, false, false);
        }
 
 
        public static BlockTable BlockTable(this Database db, OpenMode mode = OpenMode.ForRead)
        {
            return db.BlockTable(db.TransactionManager.TopTransaction, mode);
        }
 
 
        public static DimStyleTable DimStyleTable(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            return (DimStyleTable)trx.GetObject(db.DimStyleTableId, mode, false, false);
        }
 
 
        public static DimStyleTable DimStyleTable(this Database db, OpenMode mode = OpenMode.ForRead)
        {
            return db.DimStyleTable(db.TransactionManager.TopTransaction, mode);
        }
 
 
 
        public static LayerTable LayerTable(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            return (LayerTable)trx.GetObject(db.LayerTableId, mode, false, false);
        }
 
 
        public static LayerTable LayerTable(this Database db, OpenMode mode = OpenMode.ForRead)
        {
            return db.LayerTable(db.TransactionManager.TopTransaction, mode);
        }
 
        public static LinetypeTable LinetypeTable(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            return (LinetypeTable)trx.GetObject(db.LinetypeTableId, mode, false, false);
        }
 
 
        public static LinetypeTable LinetypeTable(this Database db, OpenMode mode = OpenMode.ForRead)
        {
            return db.LinetypeTable(db.TransactionManager.TopTransaction, mode);
        }
 
 
 
        public static RegAppTable RegAppTable(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            return (RegAppTable)trx.GetObject(db.RegAppTableId, mode, false, false);
        }
 
 
        public static RegAppTable RegAppTable(this Database db, OpenMode mode = OpenMode.ForRead)
        {
            return db.RegAppTable(db.TransactionManager.TopTransaction, mode);
        }
 
 
 
        public static TextStyleTable TextStyleTable(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            return (TextStyleTable)trx.GetObject(db.TextStyleTableId, mode, false, false);
        }
 
 
        public static TextStyleTable TextStyleTable(this Database db, OpenMode mode = OpenMode.ForRead)
        {
            return db.TextStyleTable(db.TransactionManager.TopTransaction, mode);
        }
 
        public static ObjectId StandardTextStyle(this Database db)
        {
          return  SymbolUtilityServices.GetTextStyleStandardId(db);
        }
 
 
        public static ObjectId ContinuousLinetypeId(this Database db)
        {
            return SymbolUtilityServices.GetLinetypeContinuousId(db);
        }
 
        public static ObjectId StandardDimStyle(this Database db, Transaction trx)
        {
            var dimtbl = db.DimStyleTable(trx);
            return dimtbl.Has(standard) ? dimtbl[standard] : db.Dimstyle;
        }
 
        public static ObjectId StandardDimStyle(this Database db)
        {
            return db.StandardDimStyle(db.TransactionManager.TopTransaction);
        }
 
 
 
        public static UcsTable UcsTable(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            return (UcsTable)trx.GetObject(db.UcsTableId, mode, false, false);
        }
 
 
        public static UcsTable UcsTable(this Database db, OpenMode mode = OpenMode.ForRead)
        {
            return db.UcsTable(db.TransactionManager.TopTransaction, mode);
        }
 
 
 
        public static ViewportTable ViewportTable(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            return (ViewportTable)trx.GetObject(db.ViewportTableId, mode, false, false);
        }
 
 
        public static ViewportTable ViewportTable(this Database db, OpenMode mode = OpenMode.ForRead)
        {
            return db.ViewportTable(db.TransactionManager.TopTransaction, mode);
        }
 
 
 
        public static ViewTable ViewTable(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            return (ViewTable)trx.GetObject(db.ViewTableId, mode, false, false);
        }
 
 
        public static ViewTable ViewTable(this Database db, OpenMode mode = OpenMode.ForRead)
        {
            return db.ViewTable(db.TransactionManager.TopTransaction, mode);
        }
 
        /// <summary>
        /// Author: Tony Tanzillo
        /// Source: http://www.theswamp.org/index.php?topic=41311.msg464457#msg464457
        /// </summary>
        /// <param name="db"></param>
        /// <param name="trx"></param>
        /// <param name="mode"></param>
        /// <returns></returns>
       public static BlockTableRecord ModelSpace(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            return (BlockTableRecord)trx.GetObject(SymbolUtilityServices.GetBlockModelSpaceId(db),mode, false, false);
        }
 
 
        public static BlockTableRecord ModelSpace(this Database db, OpenMode mode = OpenMode.ForRead)
        {
            return db.ModelSpace(db.TransactionManager.TopTransaction, mode);
        }
 
 
        
 
        /// <summary>
        /// Author: Tony Tanzillo
        /// Source: http://www.theswamp.org/index.php?topic=41311.msg464457#msg464457
        /// </summary>
        /// <param name="db"></param>
        /// <param name="trx"></param>
        /// <param name="mode"></param>
        /// <returns></returns>
        public static BlockTableRecord CurrentSpace(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            return (BlockTableRecord)trx.GetObject(db.CurrentSpaceId, mode, false, false);
        }
 
 
        public static BlockTableRecord CurrentSpace(this Database db, OpenMode mode = OpenMode.ForRead)
        {
            return db.CurrentSpace(db.TransactionManager.TopTransaction, mode);
        }        
 
 
        public static DBDictionary NamedObjectDBDictionary(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            return (DBDictionary)trx.GetObject(db.NamedObjectsDictionaryId, mode, false, false);
        }
 
 
        public static DBDictionary NamedObjectDBDictionary(this Database db, OpenMode mode = OpenMode.ForRead)
        {
            return db.NamedObjectDBDictionary(db.TransactionManager.TopTransaction, mode);
        }
 
 
        public static DBDictionary GroupDBDictionary(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            return (DBDictionary)trx.GetObject(db.GroupDictionaryId, mode, false, false);
        }
 
 
        public static DBDictionary GroupDBDictionary(this Database db, OpenMode mode = OpenMode.ForRead)
        {
            return db.GroupDBDictionary(db.TransactionManager.TopTransaction, mode);
        }
 
 
        public static DBDictionary MLStyleDBDictionary(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            return (DBDictionary)trx.GetObject(db.MLStyleDictionaryId, mode, false, false);
        }
 
 
        public static DBDictionary MLStyleDBDictionary(this Database db, OpenMode mode = OpenMode.ForRead)
        {
            return db.MLStyleDBDictionary(db.TransactionManager.TopTransaction, mode);
        }
 
        public static ObjectId StandardMLStyle(this Database db)
        {
 
            return db.StandardMLStyle(db.TransactionManager.TopTransaction);
        }
 
        public static ObjectId StandardMLStyle(this Database db, Transaction trx)
        {
            var mlDic = db.MLStyleDBDictionary(trx);
            return mlDic.Contains(standard) ? mlDic.GetAt(standard) : db.CmlstyleID;
        }
 
 
        public static DBDictionary LayoutDBDictionary(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            return (DBDictionary)trx.GetObject(db.LayoutDictionaryId, mode, false, false);
        }
 
 
        public static DBDictionary LayoutDBDictionary(this Database db, OpenMode mode = OpenMode.ForRead)
        {
            return db.LayoutDBDictionary(db.TransactionManager.TopTransaction, mode);
        }
 
 
        public static DBDictionary PlotSettingsDBDictionary(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            return (DBDictionary)trx.GetObject(db.PlotSettingsDictionaryId, mode, false, false);
        }
 
 
        public static DBDictionary PlotSettingsDBDictionary(this Database db, OpenMode mode = OpenMode.ForRead)
        {
            return db.PlotSettingsDBDictionary(db.TransactionManager.TopTransaction, mode);
        }
 
        public static DBDictionary TableStyleDBDictionary(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            return (DBDictionary)trx.GetObject(db.TableStyleDictionaryId, mode, false, false);
        }
 
 
        public static DBDictionary TableStyleDBDictionary(this Database db, OpenMode mode = OpenMode.ForRead)
        {
            return db.TableStyleDBDictionary(db.TransactionManager.TopTransaction, mode);
        }
 
 
        public static DBDictionary MLeaderStyleDBDictionary(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            return (DBDictionary)trx.GetObject(db.MLeaderStyleDictionaryId, mode, false, false);
        }
 
 
        public static DBDictionary MLeaderStyleDBDictionary(this Database db, OpenMode mode = OpenMode.ForRead)
        {
            return db.MLeaderStyleDBDictionary(db.TransactionManager.TopTransaction, mode);
        }
 
        public static ObjectId StandardMLeaderStyle(this Database db)
        {
 
            return db.StandardMLeaderStyle(db.TransactionManager.TopTransaction);
        }
 
        public static ObjectId StandardMLeaderStyle(this Database db, Transaction trx)
        {
            var mlDic = db.MLeaderStyleDBDictionary(trx);
            return mlDic.Contains(standard) ? mlDic.GetAt(standard) : db.MLeaderstyle;
        }
 
        public static GroupDictionary GroupDictionary(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead, bool includingErased = false)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            DBDictionary dic = (DBDictionary)trx.GetObject(db.GroupDictionaryId, mode, false, false);
            return includingErased
                ? new GroupDictionary(trx, dic, includingErased)
                : new GroupDictionary(trx, dic.IncludingErased, includingErased);            
        }
 
        public static GroupDictionary GroupDictionary(this Database db, OpenMode mode = OpenMode.ForRead, bool includingErased = false)
        {
            return db.GroupDictionary(db.TransactionManager.TopTransaction, mode, includingErased);
        }
 
        public static MLStyleDictionary MLStyleDictionary(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead, bool includingErased = false)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            DBDictionary dic = (DBDictionary)trx.GetObject(db.MLStyleDictionaryId, mode, false, false);
            return includingErased
                ? new MLStyleDictionary(trx, dic, includingErased)
                : new MLStyleDictionary(trx, dic.IncludingErased, includingErased);
        }
 
        public static MLStyleDictionary MLStyleDictionary(this Database db, OpenMode mode = OpenMode.ForRead, bool includingErased = false)
        {
            return db.MLStyleDictionary(db.TransactionManager.TopTransaction, mode, includingErased);
        }
 
        public static LayoutDictionary LayoutDictionary(this Database db, Transaction trx, OpenMode mode = OpenMode.ForRead, bool includingErased = false)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            DBDictionary dic = (DBDictionary)trx.GetObject(db.LayoutDictionaryId, mode, false, false);
            return includingErased
                ? new LayoutDictionary(trx, dic, includingErased)
                : new LayoutDictionary(trx, dic.IncludingErased, includingErased);
        }
 
        public static LayoutDictionary LayoutDictionary(this Database db, OpenMode mode = OpenMode.ForRead, bool includingErased = false)
        {
            return db.LayoutDictionary(db.TransactionManager.TopTransaction, mode, includingErased);
        }
 
        public static int RevisionNumber(this Database db)
        {
            DatabaseSummaryInfo info = db.SummaryInfo;
            string revisionNumberString = info.RevisionNumber;
            int revisionNumber;
            if (!revisionNumberString.IsNullOrEmpty())
            {                
                if (Int32.TryParse(revisionNumberString, out revisionNumber))
                {
                    return revisionNumber;
                }
            }
            revisionNumber = 0;
            DatabaseSummaryInfoBuilder infoBuilder = new DatabaseSummaryInfoBuilder(info);
            infoBuilder.RevisionNumber = revisionNumber.ToString();
            db.SummaryInfo = infoBuilder.ToDatabaseSummaryInfo();
            return revisionNumber;
        }
 
        public static int IncrementRevisionNumber(this Database db)
        {
            return db.AddToRevisionNumber(1);
 
        }
 
        public static int AddToRevisionNumber(this Database db, int number)
        {
            DatabaseSummaryInfo info = db.SummaryInfo;
            string revisionNumberString = info.RevisionNumber;
            int revisionNumber;
            if (revisionNumberString.IsNullOrEmpty() || !Int32.TryParse(revisionNumberString, out revisionNumber))
            {
                revisionNumber = 0;
            }
 
            int newRevisionNum = revisionNumber + number;
            if (newRevisionNum < 0)
            {
                newRevisionNum = 0;
            }
            DatabaseSummaryInfoBuilder infoBuilder = new DatabaseSummaryInfoBuilder(db.SummaryInfo);
            infoBuilder.RevisionNumber = newRevisionNum.ToString();
            db.SummaryInfo = infoBuilder.ToDatabaseSummaryInfo();
            return newRevisionNum;
 
        }
    }
}
 

Jeff H · « **Reply #20 on:** August 01, 2015, 12:21:08 AM »

Blockreferences

Code - C#: [Select]

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Autodesk.AutoCAD.Runtime;
 
namespace Autodesk.AutoCAD.DatabaseServices
{
    public static class BlockReferenceExtensions
    {
        public static BlockTableRecord GetEffectiveBlockTableRecord(this BlockReference blockref, Transaction trx)
        {
            if (blockref.IsDynamicBlock)
            {
                return blockref.DynamicBlockTableRecord.GetDBObject<BlockTableRecord>(trx, OpenMode.ForRead, false);
            }
            return blockref.BlockTableRecord.GetDBObject<BlockTableRecord>(trx, OpenMode.ForRead, false);
        }
 
        public static BlockTableRecord GetEffectiveBlockTableRecord(this BlockReference blockref)
        {
            return blockref.GetEffectiveBlockTableRecord(blockref.Database.TransactionManager.TopTransaction);
        }
 
        public static string GetEffectiveName(this BlockReference blockref, Transaction trx)
        {
            if (blockref.IsDynamicBlock)
            {
                return blockref.DynamicBlockTableRecord.GetDBObject<BlockTableRecord>(trx, OpenMode.ForRead, false).Name;
            }
            return blockref.Name;
        }
 
        public static string GetEffectiveName(this BlockReference blockref)
        {
            return blockref.GetEffectiveName(blockref.Database.TransactionManager.TopTransaction);
            
        }
 
        public static IEnumerable<AttributeReference> GetAttributeReferences(this BlockReference bref, Transaction trx, OpenMode mode = OpenMode.ForRead, bool includingErased = false, bool openObjectsOnLockedLayers = false)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            if (includingErased)
            {
                foreach (ObjectId id in bref.AttributeCollection)
                {
 
                    yield return (AttributeReference)trx.GetObject(id, mode, true, openObjectsOnLockedLayers);
 
                } 
            }
            else
            {
                foreach (ObjectId id in bref.AttributeCollection)
                {
                    if (!id.IsErased)
                    {
                        yield return (AttributeReference)trx.GetObject(id, mode, false, openObjectsOnLockedLayers);
                    }
                    
 
                } 
            }
 
 
        }
 
        public static IEnumerable<AttributeReference> GetAttributeReferences(this BlockReference bref, OpenMode mode = OpenMode.ForRead, bool includingErased = false, bool openObjectsOnLockedLayers = false)
        {
            return bref.GetAttributeReferences(bref.Database.TransactionManager.TopTransaction, mode, includingErased, openObjectsOnLockedLayers);
 
        }
 
        public static Dictionary<string, AttributeReference> GetAttributeReferenceDictionary(this BlockReference bref, Transaction trx, OpenMode mode = OpenMode.ForRead, bool includingErased = false, bool openObjectsOnLockedLayers = false)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
 
            return bref.GetAttributeReferences(trx, mode, includingErased, openObjectsOnLockedLayers).ToDictionary(a => a.Tag);
 
        }
 
        public static Dictionary<string, AttributeReference> GetAttributeReferenceDictionary(this BlockReference bref, OpenMode mode = OpenMode.ForRead, bool includingErased = false, bool openObjectsOnLockedLayers = false)
        {
            return bref.GetAttributeReferenceDictionary(bref.Database.TransactionManager.TopTransaction, mode, includingErased, openObjectsOnLockedLayers);
 
        }
    }
}
 
 

Blocktable

Code - C#: [Select]

using System.Collections.Generic;
 
namespace Autodesk.AutoCAD.DatabaseServices
{
    public static class BlockTableExtensions
    {
        public static IEnumerable<BlockTableRecord> GetBlockTableRecords(this BlockTable symbolTbl, Transaction trx, OpenMode mode = OpenMode.ForRead, SymbolTableRecordFilter filter = SymbolTableRecordFilter.None)
        {
            if (filter.IsSet(SymbolTableRecordFilter.IncludeDependent))
            {
                return symbolTbl.GetSymbolTableRecords<BlockTableRecord>(trx, mode, filter, true);
            }
            return symbolTbl.GetSymbolTableRecords<BlockTableRecord>(trx, mode, filter, true).NonDependent();
        }
 
        public static IEnumerable<BlockTableRecord> GetBlockTableRecords(this BlockTable symbolTbl, OpenMode mode = OpenMode.ForRead, SymbolTableRecordFilter filter = SymbolTableRecordFilter.None)
        {
            return symbolTbl.GetBlockTableRecords(symbolTbl.Database.TransactionManager.TopTransaction, mode, filter);
        }
 
 
        public static IEnumerable<BlockTableRecord> GetUserDefinedBlockTableRecords(this BlockTable symbolTbl, Transaction trx, OpenMode mode = OpenMode.ForRead)
        {
 
            return symbolTbl.GetSymbolTableRecords<BlockTableRecord>(trx, mode, SymbolTableRecordFilter.None, true).UserDefinedBlocks();
        }
 
        public static IEnumerable<BlockTableRecord> GetUserDefinedBlockTableRecords(this BlockTable symbolTbl, OpenMode mode = OpenMode.ForRead)
        {
            return symbolTbl.GetUserDefinedBlockTableRecords(symbolTbl.Database.TransactionManager.TopTransaction, mode);
        }
 
 
        public static IEnumerable<BlockTableRecord> GetUserCreatedBlockTableRecords(this BlockTable symbolTbl, Transaction trx, OpenMode mode = OpenMode.ForRead)
        {
 
            return symbolTbl.GetSymbolTableRecords<BlockTableRecord>(trx, mode, SymbolTableRecordFilter.None, true).UserCreatedBlocks();
        }
 
        public static IEnumerable<BlockTableRecord> GetUserCreatedBlockTableRecords(this BlockTable symbolTbl, OpenMode mode = OpenMode.ForRead)
        {
            return symbolTbl.GetUserCreatedBlockTableRecords(symbolTbl.Database.TransactionManager.TopTransaction, mode);
        }
 
 
 
        internal static ObjectId GetDatabaseBlockTableId(this BlockTable symbolTbl, Database db)
        {
            return db.BlockTableId;
        }
    }
 
}
 

BlockTableRecord

Code - C#: [Select]

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.DatabaseServices.Contracts;
using System.Diagnostics.Contracts;
//using Autodesk.AutoCAD.ApplicationServices.Core;
//using Autodesk.AutoCAD.EditorInput;
namespace Autodesk.AutoCAD.DatabaseServices
{
 public static class BlockTableRecordExtensions
    {
 
        /// <summary>
        /// Author: Tony Tanzillo
        /// Source: http://www.theswamp.org/index.php?topic=41311.msg464529#msg464529
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
     public static IEnumerable<BlockTableRecord> UserDefinedBlocks(this IEnumerable<BlockTableRecord> source)
     {
         return source.Where(btr =>
             !(
             btr.IsAnonymous ||
             btr.IsFromExternalReference ||
             btr.IsFromOverlayReference ||
             btr.IsLayout ||
             btr.IsAProxy
             )
             );
     }
 
     public static IEnumerable<BlockTableRecord> UserCreatedBlocks(this IEnumerable<BlockTableRecord> source)
     {
         return source.Where(btr =>
             !(
             btr.IsFromExternalReference ||
             btr.IsFromOverlayReference ||
             btr.IsLayout ||
             btr.IsAProxy
             )
             );
     }
        /// <summary>
        /// Author: Tony Tanzillo
        /// Source: http://www.theswamp.org/index.php?topic=41311.msg464529#msg464529
        /// Use instead of UserDefinedBlocks when anonymous blocks are needed
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
     public static IEnumerable<BlockTableRecord> NonDependent(this IEnumerable<BlockTableRecord> source)
     {
         return source.Where(btr =>
             !(
             btr.IsFromExternalReference ||
             btr.IsFromOverlayReference
             )
             );
     }
 
 
     public static IEnumerable<ObjectId> GetObjectIds<T>(this BlockTableRecord btr) where T : Entity
     {
         IntPtr impobj = RXClass.GetClass(typeof(T)).UnmanagedObject;
         foreach (ObjectId id in btr)
         {
             if (id.ObjectClass.UnmanagedObject == impobj)
             {
                 yield return id;
             }
         }
     }
 
     public static IEnumerable<ObjectId> GetObjectIds(this BlockTableRecord btr)
     {
         foreach (ObjectId id in btr)
         {
             yield return id;
         }
     }
 
        /// <summary>
        /// Author: Tony Tanzillo
        /// A combination of code written by Tony Tanzillo from 2 sources below
        /// Source1: http://www.theswamp.org/index.php?topic=42197.msg474011#msg474011
        /// Source2: http://www.theswamp.org/index.php?topic=41311.msg464457#msg464457
        /// </summary>
        /// <param name="btr"></param>
        /// <param name="mode"></param>
        /// <param name="openErased"></param>
        /// <param name="openObjectsOnLockedLayers"></param>
        /// <returns></returns>
     public static IEnumerable<Entity> GetEntities(this BlockTableRecord btr, Transaction trx, OpenMode mode = OpenMode.ForRead, bool includingErased = false, bool openObjectsOnLockedLayers = false)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
 
            foreach (ObjectId id in includingErased ? btr.IncludingErased : btr)
            {
                yield return (Entity)trx.GetObject(id, mode, includingErased, openObjectsOnLockedLayers);
            }
 
        }
 
        public static IEnumerable<Entity> GetEntities(this BlockTableRecord btr, OpenMode mode = OpenMode.ForRead, bool includingErased = false, bool openObjectsOnLockedLayers = false)
        {
            return btr.GetEntities(btr.Database.TransactionManager.TopTransaction, mode, includingErased, openObjectsOnLockedLayers);
 
        }
 
        /// <summary>
        /// Author: Tony Tanzillo
        /// A combination of code written by Tony Tanzillo from 2 sources below
        /// Source1: http://www.theswamp.org/index.php?topic=42197.msg474011#msg474011
        /// Source2: http://www.theswamp.org/index.php?topic=41311.msg464457#msg464457
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="btr"></param>
        /// <param name="mode"></param>
        /// <param name="openErased"></param>
        /// <param name="openObjectsOnLockedLayers"></param>
        /// <returns></returns>
        public static IEnumerable<T> GetEntities<T>(this BlockTableRecord btr, Transaction trx, OpenMode mode = OpenMode.ForRead, bool includingErased = false, bool openObjectsOnLockedLayers = false) where T : Entity
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
 
            IntPtr impObject = RXClass.GetClass(typeof(T)).UnmanagedObject;
 
 
            foreach (ObjectId id in includingErased ? btr.IncludingErased : btr)
            {
                if(id.ObjectClass.UnmanagedObject == impObject)
                {
                    yield return (T)trx.GetObject(id, mode, includingErased, openObjectsOnLockedLayers);
                }
 
            }
        }
 
        public static IEnumerable<T> GetEntities<T>(this BlockTableRecord btr, OpenMode mode = OpenMode.ForRead, bool includingErased = false, bool openObjectsOnLockedLayers = false) where T : Entity
        {
            return btr.GetEntities<T>(btr.Database.TransactionManager.TopTransaction, mode, includingErased, openObjectsOnLockedLayers);
        }
 
        /// <summary>
        /// Author: Tony Tanzillo
        /// A combination of code written by Tony Tanzillo from 2 sources below
        /// Source1: http://www.theswamp.org/index.php?topic=42197.msg474011#msg474011
        /// Source2: http://www.theswamp.org/index.php?topic=41311.msg464457#msg464457
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="btr"></param>
        /// <param name="mode"></param>
        /// <param name="openErased"></param>
        /// <param name="openObjectsOnLockedLayers"></param>
        /// <returns></returns>
        public static IEnumerable<T> GetEntitiesAssignableFrom<T>(this BlockTableRecord btr, Transaction trx, OpenMode mode = OpenMode.ForRead, bool includingErased = false, bool openObjectsOnLockedLayers = false) where T : Entity
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
 
            RXClass rxclass = RXClass.GetClass(typeof(T));
 
 
            foreach (ObjectId id in includingErased ? btr.IncludingErased : btr)
            {
                if (id.ObjectClass.IsDerivedFrom(rxclass))
                {
                    yield return (T)trx.GetObject(id, mode, includingErased, openObjectsOnLockedLayers);
                }
 
            }
 
        }
 
        public static IEnumerable<T> GetEntitiesAssignableFrom<T>(this BlockTableRecord btr, OpenMode mode = OpenMode.ForRead, bool includingErased = false, bool openObjectsOnLockedLayers = false) where T : Entity
        {
            return btr.GetEntitiesAssignableFrom<T>(btr.Database.TransactionManager.TopTransaction, mode, includingErased, openObjectsOnLockedLayers);
 
        }
     /// <summary>
     /// Method for getting all blockreference Ids
     /// </summary>
     /// <param name="btr"></param>
     /// <param name="directOnly"></param>
     /// <param name="forceValidity"></param>
     /// <param name="trx"></param>
     /// <returns></returns>
        public static ObjectIdCollection GetAllBlockReferenceIds(this BlockTableRecord btr, Transaction trx, bool directOnly, bool forceValidity)
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
 
            ObjectIdCollection blockReferenceIds = btr.GetBlockReferenceIds(directOnly, forceValidity);
 
         if (!btr.IsDynamicBlock) return blockReferenceIds;
         foreach (ObjectId id in btr.GetAnonymousBlockIds())
         {
             BlockTableRecord record = trx.GetObject(id, OpenMode.ForRead) as BlockTableRecord;
             blockReferenceIds.Add(record.GetBlockReferenceIds(directOnly, forceValidity));
 
         }
         return blockReferenceIds;
        }
 
        public static ObjectIdCollection GetAllBlockReferenceIds(this BlockTableRecord btr, bool directOnly, bool forceValidity)
        {
            return btr.GetAllBlockReferenceIds(btr.Database.TransactionManager.TopTransaction, directOnly, forceValidity);
        }
 
        public static IEnumerable<BlockReference> GetAllBlockReferences(this BlockTableRecord btr, Transaction trx, bool directOnly, bool forceValidity)
        {
            TransactionManager tm = btr.Database.TransactionManager;
            foreach (ObjectId id in GetAllBlockReferenceIds(btr, trx, directOnly, forceValidity))
            {
 
                yield return (BlockReference)trx.GetObject(id, OpenMode.ForRead, false, false);
            }
            
        }
 
        public static IEnumerable<BlockReference> GetAllBlockReferences(this BlockTableRecord btr, bool directOnly, bool forceValidity)
        {
            return btr.GetAllBlockReferences(btr.Database.TransactionManager.TopTransaction, directOnly, forceValidity);
        }
 
 
 
     public static IEnumerable<AttributeDefinition> GetAttributeDefinitions(this BlockTableRecord btr, Transaction trx, OpenMode mode = OpenMode.ForRead, bool includingErased = false, bool openObjectsOnLockedLayers = false)
     {
 
         return btr.GetEntities<AttributeDefinition>(trx, mode, includingErased, openObjectsOnLockedLayers);
     }
 
     public static IEnumerable<AttributeDefinition> GetAttributeDefinitions(this BlockTableRecord btr, OpenMode mode = OpenMode.ForRead, bool includingErased = false, bool openObjectsOnLockedLayers = false)
     {
         return btr.GetAttributeDefinitions(btr.Database.TransactionManager.TopTransaction, mode, includingErased, openObjectsOnLockedLayers);
     }
    }
}
 
 
 

Jeff H · « **Reply #21 on:** August 01, 2015, 12:34:44 AM »

Objectid

Code - C#: [Select]

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Autodesk.AutoCAD.DatabaseServices.Contracts;
using System.Diagnostics.Contracts;
using Autodesk.AutoCAD.Runtime;
 
namespace Autodesk.AutoCAD.DatabaseServices
{
    public static class ObjectIdExtensions
    {
 
        public static T GetDBObject<T>(this ObjectId id, Transaction trx, OpenMode mode = OpenMode.ForRead, bool openErased = false) where T : DBObject
        {
            if (id.IsNull)
            {
                throw new ArgumentNullException("id is null");
            }
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            return (T)trx.GetObject(id, mode, openErased, false);
        }
 
        public static T GetDBObject<T>(this ObjectId id, OpenMode mode = OpenMode.ForRead, bool openErased = false) where T : DBObject
        {
            return id.GetDBObject<T>(id.Database.TransactionManager.TopTransaction, mode, openErased);
        }
 
        public static DBObject GetDBObject(this ObjectId id, Transaction trx, OpenMode mode = OpenMode.ForRead, bool openErased = false)
        {
            return id.GetDBObject<DBObject>(trx, mode, openErased);
        }
 
        public static DBObject GetDBObject(this ObjectId id, OpenMode mode = OpenMode.ForRead, bool openErased = false)
        {
            return id.GetDBObject<DBObject>(id.Database.TransactionManager.TopTransaction, mode, openErased);
        }
 
 
 
 
        public static T GetEntity<T>(this ObjectId id, Transaction trx, OpenMode mode = OpenMode.ForRead, bool openErased = false, bool forceOpenOnLockedLayer = false) where T : Entity
        {
            if (id.IsNull)
            {
                throw new ArgumentNullException("id is null");
            }
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            return (T)trx.GetObject(id, mode, openErased, forceOpenOnLockedLayer);
        }
        
 
        public static T GetEntity<T>(this ObjectId id, OpenMode mode = OpenMode.ForRead, bool openErased = false, bool forceOpenOnLockedLayer = false) where T : Entity
        {
            return id.GetEntity<T>(id.Database.TransactionManager.TopTransaction, mode, openErased, forceOpenOnLockedLayer);
        }
 
 
        public static Entity GetEntity(this ObjectId id, Transaction trx, OpenMode mode = OpenMode.ForRead, bool openErased = false, bool forceOpenOnLockedLayer = false)
        {
            return id.GetEntity<Entity>(trx, mode, openErased, forceOpenOnLockedLayer);
        }
 
        public static Entity GetEntity(this ObjectId id, OpenMode mode = OpenMode.ForRead, bool openErased = false, bool forceOpenOnLockedLayer = false) 
        {
            return id.GetEntity<Entity>(id.Database.TransactionManager.TopTransaction, mode, openErased, forceOpenOnLockedLayer);
        }
 
        public static IEnumerable<T> GetEntities<T>(this IEnumerable<ObjectId> ids, Transaction trx, OpenMode mode = OpenMode.ForRead, bool openErased = false, bool forceOpenOnLockedLayer = false) where T : Entity
        {
            if (ids == null)
            {
                throw new ArgumentNullException("ids is null");
            }
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            foreach (ObjectId id in ids)
            {
               yield return (T)trx.GetObject(id, mode, openErased, forceOpenOnLockedLayer);
            }
            
        }
 
        public static IEnumerable<T> GetEntities<T>(this IEnumerable<ObjectId> ids, OpenMode mode = OpenMode.ForRead, bool openErased = false, bool forceOpenOnLockedLayer = false) where T : Entity
        {
            ObjectId id = ids.First();
            if (id == null)
            {
                throw new ArgumentNullException("id is null");
            }
            return ids.GetEntities<T>(id.Database.TransactionManager.TopTransaction, mode, openErased, forceOpenOnLockedLayer);
        }
 
        public static IEnumerable<Entity> GetEntities(this IEnumerable<ObjectId> ids, Transaction trx, OpenMode mode = OpenMode.ForRead, bool openErased = false, bool forceOpenOnLockedLayer = false)
        {
             return ids.GetEntities<Entity>(trx, mode, openErased, forceOpenOnLockedLayer);
 
        }
 
        public static IEnumerable<Entity> GetEntities(this IEnumerable<ObjectId> ids, OpenMode mode = OpenMode.ForRead, bool openErased = false, bool forceOpenOnLockedLayer = false)
        {
            ObjectId id = ids.First();
            if (id == null)
            {
                throw new ArgumentNullException("id is null");
            }
            return ids.GetEntities<Entity>(id.Database.TransactionManager.TopTransaction, mode, openErased, forceOpenOnLockedLayer);
        }
 
        public static IEnumerable<T> GetDBObjects<T>(this IEnumerable<ObjectId> ids, Transaction trx, OpenMode mode = OpenMode.ForRead, bool openErased = false) where T : DBObject
        {
            if (ids == null)
            {
                throw new ArgumentNullException("ids is null");
            }
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            foreach (ObjectId id in ids)
            {
                yield return (T)trx.GetObject(id, mode, openErased, false);
            }
 
        }
 
        public static IEnumerable<T> GetDBObjects<T>(this IEnumerable<ObjectId> ids, OpenMode mode = OpenMode.ForRead, bool openErased = false) where T : DBObject
        {
            ObjectId id = ids.First();
            if (id == null)
            {
                throw new ArgumentNullException("id is null");
            }
            return ids.GetDBObjects<T>(id.Database.TransactionManager.TopTransaction, mode, openErased);
        }
 
        public static IEnumerable<DBObject> GetDBObjects(this IEnumerable<ObjectId> ids, Transaction trx, OpenMode mode = OpenMode.ForRead, bool openErased = false)
        {
            return ids.GetDBObjects<DBObject>(trx, mode, openErased);
 
        }
 
        public static IEnumerable<DBObject> GetDBObjects(this IEnumerable<ObjectId> ids, OpenMode mode = OpenMode.ForRead, bool openErased = false)
        {
            ObjectId id = ids.First();
            if (id == null)
            {
                throw new ArgumentNullException("id is null");
            }
            return ids.GetDBObjects<DBObject>(id.Database.TransactionManager.TopTransaction, mode, openErased);
        }
    }
}
 
 

SymbolTable

Code - C#: [Select]

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Autodesk.AutoCAD.DatabaseServices.Contracts;
using Autodesk.AutoCAD.Runtime;
 
namespace Autodesk.AutoCAD.DatabaseServices
{
    public static class SymbolTableExtensions
    {
        public static IEnumerable<ObjectId> GetObjectIds(this SymbolTable st)
        {
            foreach (ObjectId id in st)
            {
                yield return id;
            }
        }
 
        internal static IEnumerable<T> GetSymbolTableRecords<T>(this SymbolTable symbolTbl, Transaction trx,
            OpenMode mode, SymbolTableRecordFilter filter, bool filterDependecyById) where T : SymbolTableRecord
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
 
            bool includingErased = filter.IsSet(SymbolTableRecordFilter.IncludedErased);
 
            if (filter.IsSet(SymbolTableRecordFilter.IncludeDependent))
            {
                foreach (ObjectId id in includingErased ? symbolTbl.IncludingErased : symbolTbl)
                {
                    yield return (T)trx.GetObject(id, mode, includingErased, false);
                }
            }
 
            else
            {
                if (filterDependecyById)
                {
                    IntPtr dbIntPtr = symbolTbl.Database.UnmanagedObject;
                    foreach (ObjectId id in includingErased ? symbolTbl.IncludingErased : symbolTbl)
                    {
                        if (id.OriginalDatabase.UnmanagedObject == dbIntPtr)
                        {
                            yield return (T)trx.GetObject(id, mode, includingErased, false);
                        }
                    }
                }
                else
                {
                    foreach (ObjectId id in includingErased ? symbolTbl.IncludingErased : symbolTbl)
                    {
                        T current = (T)trx.GetObject(id, mode, includingErased, false);
                        if (!current.IsDependent)
                        {
                            yield return current;
                        }
                    }
                }
 
            }
 
 
        }
 
 
        /// <summary>
        /// Author: Gile
        /// Source: http://www.theswamp.org/index.php?topic=42539.msg477455#msg477455
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static ObjectId ImportSymbolTableRecord<T>(this Database targetDb, string sourceFile,
            DuplicateRecordCloning cloningStyle, string recordName)
            where T : SymbolTable
        {
 
            using (var sourceDb = new Database(false, true))
            {
                sourceDb.ReadDwgFile(sourceFile, System.IO.FileShare.ReadWrite, false, "");
                ObjectId sourceTableId, targetTableId;
                switch (typeof (T).Name)
                {
                    case "BlockTable":
                        sourceTableId = sourceDb.BlockTableId;
                        targetTableId = targetDb.BlockTableId;
                        break;
                    case "DimStyleTable":
                        sourceTableId = sourceDb.DimStyleTableId;
                        targetTableId = targetDb.DimStyleTableId;
                        break;
                    case "LayerTable":
                        sourceTableId = sourceDb.LayerTableId;
                        targetTableId = targetDb.LayerTableId;
                        break;
                    case "LinetypeTable":
                        sourceTableId = sourceDb.LinetypeTableId;
                        targetTableId = targetDb.LinetypeTableId;
                        break;
                    case "RegAppTable":
                        sourceTableId = sourceDb.RegAppTableId;
                        targetTableId = targetDb.RegAppTableId;
                        break;
                    case "TextStyleTable":
                        sourceTableId = sourceDb.TextStyleTableId;
                        targetTableId = targetDb.TextStyleTableId;
                        break;
                    case "UcsTable":
                        sourceTableId = sourceDb.UcsTableId;
                        targetTableId = targetDb.UcsTableId;
                        break;
                    case "ViewTable":
                        sourceTableId = sourceDb.ViewportTableId;
                        targetTableId = targetDb.ViewportTableId;
                        break;
                    case "ViewportTable":
                        sourceTableId = sourceDb.ViewportTableId;
                        targetTableId = targetDb.ViewportTableId;
                        break;
                    default:
                        throw new ArgumentException("Requires a concrete type derived from SymbolTable");
                }
 
                using (Transaction tr = sourceDb.TransactionManager.StartTransaction())
                {
 
                    T sourceTable = (T) tr.GetObject(sourceTableId, OpenMode.ForRead);
                    if (!sourceTable.Has(recordName))
                    {
                        return ObjectId.Null;
                    }
                    var idCol = new ObjectIdCollection();
                    ObjectId sourceTableRecordId = sourceTable[recordName];
                    idCol.Add(sourceTableRecordId);
                    var idMap = new IdMapping();
                    sourceDb.WblockCloneObjects(idCol, targetTableId, idMap, cloningStyle, false);
                    tr.Commit();
                    return idMap[sourceTableRecordId].Value;
                }
            }
        }
 
 
        /// <summary>
        /// Author: Gile
        /// Source: http://www.theswamp.org/index.php?topic=42539.msg477455#msg477455
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool ImportSymbolTableRecords<T>(this Database targetDb, string sourceFile,
            DuplicateRecordCloning cloningStyle, params string[] recordNames)
            where T : SymbolTable
        {
            using (var sourceDb = new Database(false, true))
            {
                sourceDb.ReadDwgFile(sourceFile, System.IO.FileShare.Read, false, "");
                ObjectId sourceTableId, targetTableId;
                switch (typeof (T).Name)
                {
                    case "BlockTable":
                        sourceTableId = sourceDb.BlockTableId;
                        targetTableId = targetDb.BlockTableId;
                        break;
                    case "DimStyleTable":
                        sourceTableId = sourceDb.DimStyleTableId;
                        targetTableId = targetDb.DimStyleTableId;
                        break;
                    case "LayerTable":
                        sourceTableId = sourceDb.LayerTableId;
                        targetTableId = targetDb.LayerTableId;
                        break;
                    case "LinetypeTable":
                        sourceTableId = sourceDb.LinetypeTableId;
                        targetTableId = targetDb.LinetypeTableId;
                        break;
                    case "RegAppTable":
                        sourceTableId = sourceDb.RegAppTableId;
                        targetTableId = targetDb.RegAppTableId;
                        break;
                    case "TextStyleTable":
                        sourceTableId = sourceDb.TextStyleTableId;
                        targetTableId = targetDb.TextStyleTableId;
                        break;
                    case "UcsTable":
                        sourceTableId = sourceDb.UcsTableId;
                        targetTableId = targetDb.UcsTableId;
                        break;
                    case "ViewTable":
                        sourceTableId = sourceDb.ViewportTableId;
                        targetTableId = targetDb.ViewportTableId;
                        break;
                    case "ViewportTable":
                        sourceTableId = sourceDb.ViewportTableId;
                        targetTableId = targetDb.ViewportTableId;
                        break;
                    default:
                        throw new ArgumentException("Requires a concrete type derived from SymbolTable");
                }
 
                using (var tr = sourceDb.TransactionManager.StartTransaction())
                {
                    var allImported = true;
                    var sourceTable = (T) tr.GetObject(sourceTableId, OpenMode.ForRead);
                    var idCol = new ObjectIdCollection();
                    foreach (var recordName in recordNames)
                    {
                        if (sourceTable.Has(recordName))
                        {
                            idCol.Add(sourceTable[recordName]);
                        }
                        else
                        {
                            allImported = false;
                        }
                    }
 
                    var idMap = new IdMapping();
                    sourceDb.WblockCloneObjects(idCol, targetTableId, idMap, cloningStyle, false);
                    tr.Commit();
                    return allImported;
                }
            }
        }
 
    }
}
 

DBDictionary

Code - C#: [Select]

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Autodesk.AutoCAD.Runtime;
using System.Diagnostics.Contracts;
using Autodesk.AutoCAD.DatabaseServices.Contracts;
 
namespace Autodesk.AutoCAD.DatabaseServices
{
    public static class DBDictionaryExtensions
    {
        public static IEnumerable<T> GetEntries<T>(this DBDictionary dic, Transaction trx, OpenMode mode = OpenMode.ForRead, bool includingErased = false) where T : DBObject
        {
            if (trx == null)
            {
                throw new NoActiveTransactionException("No active Transaction");
            }
            foreach (var entry in includingErased ? dic.IncludingErased : dic)
            {
                yield return (T)trx.GetObject(entry.Value, mode, includingErased, false);
            }
        }
 
        public static IEnumerable<T> GetEntries<T>(this DBDictionary dic, OpenMode mode = OpenMode.ForRead, bool includingErased = false) where T : DBObject
        {
            return dic.GetEntries<T>(dic.Database.TransactionManager.TopTransaction, mode, includingErased);
        }
    }
}
 
 

DimstyleTable

Code - C#: [Select]

using System.Collections.Generic;
 
namespace Autodesk.AutoCAD.DatabaseServices
{
    public static class DimStyleTableExtensions
    {
 
        public static IEnumerable<DimStyleTableRecord> GetDimStyleTableRecords(this DimStyleTable symbolTbl, Transaction trx, OpenMode mode = OpenMode.ForRead, SymbolTableRecordFilter filter = SymbolTableRecordFilter.None)
        {
            return symbolTbl.GetSymbolTableRecords<DimStyleTableRecord>(trx, mode, filter, true);
        }
 
        public static IEnumerable<DimStyleTableRecord> GetDimStyleTableRecords(this DimStyleTable symbolTbl, OpenMode mode = OpenMode.ForRead, SymbolTableRecordFilter filter = SymbolTableRecordFilter.None)
        {
            return symbolTbl.GetSymbolTableRecords<DimStyleTableRecord>(symbolTbl.Database.TransactionManager.TopTransaction, mode, filter, true);
        }
 
    }
}
 
 

LayerTable

Code - C#: [Select]

using System.Collections.Generic;
 
namespace Autodesk.AutoCAD.DatabaseServices
{
    public static class LayerTableExtensions
    {
 
        public static IEnumerable<LayerTableRecord> GetLayerTableRecords(this LayerTable symbolTbl, Transaction trx, OpenMode mode = OpenMode.ForRead, SymbolTableRecordFilter filter = SymbolTableRecordFilter.None)
        {
            return symbolTbl.GetSymbolTableRecords<LayerTableRecord>(trx, mode, filter, false);
        }
 
        public static IEnumerable<LayerTableRecord> GetLayerTableRecords(this LayerTable symbolTbl, OpenMode mode = OpenMode.ForRead, SymbolTableRecordFilter filter = SymbolTableRecordFilter.None)
        {
            return symbolTbl.GetSymbolTableRecords<LayerTableRecord>(symbolTbl.Database.TransactionManager.TopTransaction, mode, filter, false);
        }
 
    }
 
 
}
 
 

Jeff H · « **Reply #22 on:** August 01, 2015, 12:42:12 AM »

LineTypeTable

Code - C#: [Select]

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Autodesk.AutoCAD.DatabaseServices
{
 
 
    public static class LinetypeTableExtensions
    {
 
        public static IEnumerable<LinetypeTableRecord> GetLinetypeTableRecords(this LinetypeTable symbolTbl, Transaction trx, OpenMode mode = OpenMode.ForRead, SymbolTableRecordFilter filter = SymbolTableRecordFilter.None)
        {
            return symbolTbl.GetSymbolTableRecords<LinetypeTableRecord>(trx, mode, filter, false);
        }
 
        public static IEnumerable<LinetypeTableRecord> GetLinetypeTableRecords(this LinetypeTable symbolTbl, OpenMode mode = OpenMode.ForRead, SymbolTableRecordFilter filter = SymbolTableRecordFilter.None)
        {
            return symbolTbl.GetSymbolTableRecords<LinetypeTableRecord>(symbolTbl.Database.TransactionManager.TopTransaction, mode, filter, false);
        }
 
    }
}
 
 

ObjectIDCollection

Code - C#: [Select]

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Autodesk.AutoCAD.DatabaseServices
{
    public static class ObjectIdCollectionExtensions
    {
        
        public static void Add(this ObjectIdCollection thisIds, ObjectIdCollection ids)
        {
            foreach (ObjectId id in ids)
            {
                thisIds.Add(id);
            }
        }
 
        public static void Add(this ObjectIdCollection thisIds, IEnumerable<ObjectId> ids)
        {
            foreach (ObjectId id in ids)
            {
                thisIds.Add(id);
            }
        }
 
 
 
        public static ObjectId[] ToArray(this ObjectIdCollection ids)
        {
            ObjectId[] idsArray = new ObjectId[ids.Count];
            ids.CopyTo(idsArray, 0);
            return idsArray;
        }
 
        //public static ObjectId[] ToArray(this IEnumerable<ObjectId> ids)
        //{
        //    return ids.ToArray();
        //}
 
        public static IEnumerable<ObjectId> Where<T>(this ObjectIdCollection source, Transaction trx, Func<T, bool> predicate) where T : DBObject
        {
            if (source.IsNull())
            {
                throw new ArgumentNullException("source");
            }
            if (predicate.IsNull())
            {
                throw new ArgumentNullException("predicate");
            }
            return WhereImpl<T>(source, trx, predicate);
        }
 
        public static IEnumerable<ObjectId> Where<T>(this ObjectIdCollection source, Func<T, bool> predicate) where T : DBObject
        {
 
            return Where<T>(source, HostApplicationServices.WorkingDatabase.TransactionManager.TopTransaction,  predicate);
        }
 
        private static IEnumerable<ObjectId> WhereImpl<T>(this ObjectIdCollection source, Transaction trx, Func<T, bool> predicate) where T : DBObject
        {
            
            foreach (ObjectId item in source)
            {
                T dbo = (T)trx.GetObject(item, OpenMode.ForRead, false, false);
                if (predicate(dbo))
                {
                    yield return item;
                }
 
            }
        }
        public static ObjectIdCollection ToObjectIdCollection(this IEnumerable<ObjectId> source)
        {
 
            return new ObjectIdCollection(source.ToArray());
        }
 
        public static ObjectIdCollection ToObjectIdCollection(this IEnumerable<DBObject> source)
        {
            ObjectIdCollection ids = new ObjectIdCollection();
            foreach (var dbObject in source)
            {
                ids.Add(dbObject.ObjectId);
            }
            return ids;
        }
 
 
    }
}
 

TextStyleTableRecords

Code - C#: [Select]

using System.Collections.Generic;
using System.Linq;
 
namespace Autodesk.AutoCAD.DatabaseServices
{
    public static class TextStyleTableExtensions
    {
 
 
        public static IEnumerable<TextStyleTableRecord> GetAllTextStyleTableRecords(this TextStyleTable symbolTbl, Transaction trx, OpenMode mode = OpenMode.ForRead, SymbolTableRecordFilter filter = SymbolTableRecordFilter.None)
        {
            return symbolTbl.GetSymbolTableRecords<TextStyleTableRecord>(trx, mode, filter, true);
        }
 
        public static IEnumerable<TextStyleTableRecord> GetAllTextStyleTableRecords(this TextStyleTable symbolTbl, OpenMode mode = OpenMode.ForRead, SymbolTableRecordFilter filter = SymbolTableRecordFilter.None)
        {
            return symbolTbl.GetSymbolTableRecords<TextStyleTableRecord>(symbolTbl.Database.TransactionManager.TopTransaction, mode, filter, true);
        }
 
        public static IEnumerable<TextStyleTableRecord> GetTextStyleTableRecords(this TextStyleTable symbolTbl, Transaction trx, OpenMode mode = OpenMode.ForRead, SymbolTableRecordFilter filter = SymbolTableRecordFilter.None)
        {
            return symbolTbl.GetSymbolTableRecords<TextStyleTableRecord>(trx, mode, filter, true).Where(txt => !txt.IsShapeFile);
        }
 
        public static IEnumerable<TextStyleTableRecord> GetTextStyleTableRecords(this TextStyleTable symbolTbl, OpenMode mode = OpenMode.ForRead, SymbolTableRecordFilter filter = SymbolTableRecordFilter.None)
        {
            return symbolTbl.GetTextStyleTableRecords(symbolTbl.Database.TransactionManager.TopTransaction, mode, filter);
        }
 
        public static IEnumerable<TextStyleTableRecord> GetShapeFileTableRecords(this TextStyleTable symbolTbl, Transaction trx, OpenMode mode = OpenMode.ForRead, SymbolTableRecordFilter filter = SymbolTableRecordFilter.None)
        {
            return symbolTbl.GetSymbolTableRecords<TextStyleTableRecord>(trx, mode, filter, true).Where(txt => txt.IsShapeFile);
        }
 
        public static IEnumerable<TextStyleTableRecord> GetShapeFileTableRecords(this TextStyleTable symbolTbl, OpenMode mode = OpenMode.ForRead, SymbolTableRecordFilter filter = SymbolTableRecordFilter.None)
        {
            return symbolTbl.GetShapeFileTableRecords(symbolTbl.Database.TransactionManager.TopTransaction, mode, filter);
        }
 
    }
}
 

Jeff H · « **Reply #23 on:** August 01, 2015, 12:46:26 AM »

Not sure how other than post whole project

Atook · « **Reply #24 on:** August 01, 2015, 02:02:54 PM »

Great stuff, I can't believe I didn't find this thread earlier!

Thanks Jeff, for posting, and to others (Gile + Tony) for their contributions.

Just getting a look at how you organize a project is a huge help for a newb like me.

And the code..

Thanks again.

sybold · « **Reply #25 on:** August 04, 2015, 07:09:19 AM »

would a git repository not be a better solution to share and exchange the code, others can submit code easily that way too

nobody · « **Reply #26 on:** August 07, 2015, 12:10:02 AM »

You guys must have an incredible library of pretty cool stuff

Thanks for sharing.

Jeff H · « **Reply #27 on:** August 14, 2015, 03:19:57 PM »

Looking for a few more folks to join private repo on github to help clean up a little and document some before making public, anyone interested let me know.

sybold · « **Reply #28 on:** August 15, 2015, 08:46:40 AM »

sure, no problem

Jeff H · « **Reply #29 on:** August 15, 2015, 09:58:17 AM »

PM me or post your github username or email registered with github

News:

Author Topic: Screw it I give up (Read 10467 times)

JohnK

Re: Screw it I give up

Jeff H

Re: Screw it I give up

Jeff H

Re: Screw it I give up

CADbloke

Re: Screw it I give up

Jeff H

Re: Screw it I give up

Jeff H

Re: Screw it I give up

Jeff H

Re: Screw it I give up

Jeff H

Re: Screw it I give up

Jeff H

Re: Screw it I give up

Atook

Re: Screw it I give up

sybold

Re: Screw it I give up

nobody

Re: Screw it I give up

Jeff H

Re: Screw it I give up

sybold

Re: Screw it I give up

Jeff H

Re: Screw it I give up