private List <_AcDb.ObjectId> GetFgAnz(_AcGe.Point3d minExt, _AcGe.Point3d maxExt, _AcDb.ObjectId elFG)
        {
            List <_AcDb.ObjectId> Ret = new List <_AcDb.ObjectId>();

            _AcEd.Editor          ed     = _AcAp.Application.DocumentManager.MdiActiveDocument.Editor;
            _AcEd.SelectionFilter filter = new _AcEd.SelectionFilter(new _AcDb.TypedValue[] {
                new _AcDb.TypedValue((int)_AcDb.DxfCode.Start, "*POLYLINE"),
                new _AcDb.TypedValue((int)_AcDb.DxfCode.LayerName, _FgLayer)
            });
            _AcEd.PromptSelectionResult res = null;
            res = ed.SelectCrossingWindow(minExt, maxExt, filter);
            //res = ed.SelectAll(filter);
            if (res.Status != _AcEd.PromptStatus.OK)
            {
                // todo: logging: lot4net?
                return(Ret);
            }

#if BRX_APP
            _AcEd.SelectionSet ss = res.Value;
#else
            using (_AcEd.SelectionSet ss = res.Value)
#endif
            {
                _AcDb.ObjectId[]         idArray = ss.GetObjectIds();
                _AcDb.Database           db      = _AcAp.Application.DocumentManager.MdiActiveDocument.Database;
                _AcDb.TransactionManager tm      = db.TransactionManager;
                _AcDb.Transaction        myT     = tm.StartTransaction();
                try
                {
                    for (int i = 0; i < idArray.Length; i++)
                    {
                        _AcDb.ObjectId oid = idArray[i];
                        if (!oid.Equals(elFG))
                        {
                            if (PolyInPoly(tm, oid, elFG))
                            {
                                AddRbToRetCol(Ret, tm, oid);
                            }
                        }
                    }
                    myT.Commit();
                }
                finally
                {
                    myT.Dispose();
                }
            }

            return(Ret);
        }
        private void AddRbToRetCol(List <_AcDb.ObjectId> Ret, _AcDb.TransactionManager tm, _AcDb.ObjectId elFG)
        {
            _AcDb.Extents3d ext    = GetExtents(tm, elFG);
            _AcGe.Point3d   minExt = new _AcGe.Point3d(ext.MinPoint.X - ABSTANDTEXT, ext.MinPoint.Y - ABSTANDTEXT, ext.MinPoint.Z);
            _AcGe.Point3d   maxExt = new _AcGe.Point3d(ext.MaxPoint.X + ABSTANDTEXT, ext.MaxPoint.Y + ABSTANDTEXT, ext.MaxPoint.Z);

            _AcEd.Editor          ed     = _AcAp.Application.DocumentManager.MdiActiveDocument.Editor;
            _AcEd.SelectionFilter filter = new _AcEd.SelectionFilter(new _AcDb.TypedValue[] {
                new _AcDb.TypedValue((int)_AcDb.DxfCode.Start, "INSERT"),
                new _AcDb.TypedValue((int)_AcDb.DxfCode.BlockName, _RaumblockName)
            });
            _AcEd.PromptSelectionResult res = null;
            res = ed.SelectCrossingWindow(minExt, maxExt, filter);
            if (res.Status != _AcEd.PromptStatus.OK)
            {
                // todo: logging: lot4net?
                return;
            }

#if BRX_APP
            _AcEd.SelectionSet ss = res.Value;
#else
            using (_AcEd.SelectionSet ss = res.Value)
#endif
            {
                _AcDb.ObjectId[] idArray = ss.GetObjectIds();
                for (int i = 0; i < idArray.Length; i++)
                {
                    _AcDb.ObjectId oid = idArray[i];
                    using (_AcDb.DBObject pEntity = tm.GetObject(oid, _AcDb.OpenMode.ForRead, false))
                    {
                        using (_AcDb.Entity entElFG = tm.GetObject(elFG, _AcDb.OpenMode.ForRead, false) as _AcDb.Entity)
                        {
                            if (pEntity is _AcDb.BlockReference)
                            {
                                _AcDb.BlockReference br = pEntity as _AcDb.BlockReference;
                                if (AreaEngine.InPoly(br.Position, entElFG))
                                {
                                    Ret.Add(oid);
                                }
                            }
                        }
                    }
                }
            }
        }
示例#3
0
        private bool SelectBlocks()
        {
            var ed = _AcAp.Application.DocumentManager.MdiActiveDocument.Editor;

            _AcEd.SelectionFilter filter = new _AcEd.SelectionFilter(new _AcDb.TypedValue[] {
                new _AcDb.TypedValue((int)_AcDb.DxfCode.Start, "INSERT"),
            });

            _AcEd.PromptSelectionResult res = ed.SelectAll(filter);
            //if (res.Status != _AcEd.PromptStatus.OK) return false;

            List <_AcDb.ObjectId> selectedBlocks = new List <_AcDb.ObjectId>();

#if BRX_APP
            _AcEd.SelectionSet ss = res.Value;
#else
            using (_AcEd.SelectionSet ss = res.Value)
#endif
            {
                if (ss == null)
                {
                    return(false);
                }
                selectedBlocks.AddRange(ss.GetObjectIds().ToList());
            }

            var doc = _AcAp.Application.DocumentManager.MdiActiveDocument;
            using (var trans = doc.TransactionManager.StartTransaction())
            {
                _BlocksForExcelExport = selectedBlocks.Where(oid => IsBlockToUse(oid, trans, _BlockName)).ToList();
                trans.Commit();
            }

            log.InfoFormat("Anzahl gefundener Blöcke namens '{0}': {1}.", _BlockName, _BlocksForExcelExport.Count.ToString());

            if (_BlocksForExcelExport.Count > 0)
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
示例#4
0
        private List <_AcDb.ObjectId> SelectRaumBlocks()
        {
            string hkBlockName = RaumBlockName;
            var    ed          = _AcAp.Application.DocumentManager.MdiActiveDocument.Editor;

            _AcEd.SelectionFilter filter = new _AcEd.SelectionFilter(new _AcDb.TypedValue[] {
                new _AcDb.TypedValue((int)_AcDb.DxfCode.Start, "INSERT"),
                //new _AcDb.TypedValue((int)_AcDb.DxfCode.BlockName,hkBlockName)
            });

            _AcEd.PromptSelectionResult res = ed.GetSelection(filter);
            if (res.Status != _AcEd.PromptStatus.OK)
            {
                return(new List <_AcDb.ObjectId>());
            }

#if BRX_APP
            SelectionSet ss = res.Value;
#else
            using (_AcEd.SelectionSet ss = res.Value)
#endif

            {
                List <_AcDb.ObjectId> theBlockOids = new List <_AcDb.ObjectId>();

                _AcAp.Document doc = _AcAp.Application.DocumentManager.MdiActiveDocument;
                using (_AcDb.Transaction myT = doc.TransactionManager.StartTransaction())
                {
                    var lstBlocks = ss.GetObjectIds();
                    foreach (var oid in lstBlocks)
                    {
                        var br = myT.GetObject(oid, _AcDb.OpenMode.ForRead) as _AcDb.BlockReference;
                        if (br != null && string.Compare(Plan2Ext.Globs.GetBlockname(br, myT), hkBlockName, StringComparison.OrdinalIgnoreCase) == 0)
                        {
                            theBlockOids.Add(oid);
                        }
                    }
                    myT.Commit();
                }
                return(theBlockOids);
                //return ss.GetObjectIds().ToList();
            }
        }
        private List <_AcDb.ObjectId> selRB(_AcGe.Point3d minExt, _AcGe.Point3d maxExt)
        {
            _AcEd.Editor          ed     = _AcAp.Application.DocumentManager.MdiActiveDocument.Editor;
            _AcEd.SelectionFilter filter = new _AcEd.SelectionFilter(new _AcDb.TypedValue[] {
                new _AcDb.TypedValue((int)_AcDb.DxfCode.Start, "INSERT"),
                new _AcDb.TypedValue((int)_AcDb.DxfCode.BlockName, _RaumblockName)
            });
            _AcEd.PromptSelectionResult res = null;
            res = ed.SelectCrossingWindow(minExt, maxExt, filter);
            if (res.Status != _AcEd.PromptStatus.OK)
            {
                log.Warn("Fehler beim Auswählen der Raumblöcke!");
                return(new List <_AcDb.ObjectId>());
            }

#if BRX_APP
            _AcEd.SelectionSet ss = res.Value;
#else
            using (_AcEd.SelectionSet ss = res.Value)
#endif
            {
                return(ss.GetObjectIds().ToList());
            }
        }
示例#6
0
        internal bool SelectFgAndRb(List <_AcDb.ObjectId> flaechenGrenzen, List <_AcDb.ObjectId> raumBloecke, string fgLayer, string rbName)
        {
            flaechenGrenzen.Clear();
            raumBloecke.Clear();

            log.Debug("Auswahl Flächengrenzen und Raumblöcke");
            _AcEd.PromptSelectionResult res    = null;
            _AcEd.SelectionFilter       filter = new _AcEd.SelectionFilter(new _AcDb.TypedValue[] {
                new _AcDb.TypedValue((int)_AcDb.DxfCode.Operator, "<OR"),

                new _AcDb.TypedValue((int)_AcDb.DxfCode.Operator, "<AND"),
                new _AcDb.TypedValue((int)_AcDb.DxfCode.Start, "*POLYLINE"),
                new _AcDb.TypedValue((int)_AcDb.DxfCode.LayerName, fgLayer),
                new _AcDb.TypedValue((int)_AcDb.DxfCode.Operator, "AND>"),

                new _AcDb.TypedValue((int)_AcDb.DxfCode.Operator, "<AND"),
                new _AcDb.TypedValue((int)_AcDb.DxfCode.Start, "INSERT"),
                //new _AcDb.TypedValue((int)_AcDb.DxfCode.BlockName ,rbName  ),
                new _AcDb.TypedValue((int)_AcDb.DxfCode.Operator, "AND>"),

                new _AcDb.TypedValue((int)_AcDb.DxfCode.Operator, "OR>")
            });

            _AcEd.PromptSelectionOptions SelOpts = new _AcEd.PromptSelectionOptions();
            SelOpts.MessageForAdding = "Raumblöcke und Flächengrenzen wählen: ";

            res = _Editor.GetSelection(SelOpts, filter);
            if (res.Status != _AcEd.PromptStatus.OK)
            {
                log.Debug("Auswahl wurde abgebrochen.");
                if (res.Status == _AcEd.PromptStatus.Cancel)
                {
                    return(false);
                }
                else
                {
                    return(true);
                }
            }

#if BRX_APP
            _AcEd.SelectionSet ss = res.Value;
#else
            using (_AcEd.SelectionSet ss = res.Value)
#endif
            {
                _AcDb.ObjectId[] idArray = ss.GetObjectIds();

                _AcDb.Database           db  = _AcAp.Application.DocumentManager.MdiActiveDocument.Database;
                _AcDb.TransactionManager tm  = db.TransactionManager;
                _AcDb.Transaction        myT = tm.StartTransaction();
                try
                {
                    for (int i = 0; i < idArray.Length; i++)
                    {
                        _AcDb.ObjectId oid = idArray[i];
                        using (_AcDb.DBObject dbobj = tm.GetObject(oid, _AcDb.OpenMode.ForRead, false) as _AcDb.Entity)
                        {
                            _AcDb.Entity ent = dbobj as _AcDb.Entity;
                            if (ent != null)
                            {
                                if (ent is _AcDb.BlockReference)
                                {
                                    if (string.Compare(rbName, Plan2Ext.Globs.GetBlockname((_AcDb.BlockReference)ent, myT), StringComparison.OrdinalIgnoreCase) == 0)
                                    {
                                        raumBloecke.Add(oid);
                                    }
                                }
                                else
                                {
                                    flaechenGrenzen.Add(oid);
                                }
                            }
                        }
                    }
                    myT.Commit();
                }
                finally
                {
                    myT.Dispose();
                }
            }

            log.DebugFormat(CultureInfo.CurrentCulture, "Auswahl: Raumblöcke {0}, Flächengrenzen {1}", raumBloecke.Count, flaechenGrenzen.Count);

            return(true);
        }