Example #1
0
        // Zoom via COM


        private static void ZoomWin2(

            _AcEd.Editor ed, _AcGe.Point3d min, _AcGe.Point3d max

            )
        {
            _AcInt.AcadApplication app =

                (_AcInt.AcadApplication)_AcAp.Application.AcadApplication;


            double[] lower =

                new double[3] {
                min.X, min.Y, min.Z
            };

            double[] upper

                = new double[3] {
                max.X, max.Y, max.Z
                };


            app.ZoomWindow(lower, upper);
        }
Example #2
0
        }                                                   // for sorting


        public _Area_v2(_Db.ObjectId id, _Ge.Point3d s, _Ge.Point3d e)
        {
            _id = id;

            _start = s;
            _end   = e;
        }
Example #3
0
        /// <summary>
        /// Створює елементи вектору з данними виносу.
        /// </summary>
        private void CreateDrawingStakeOut()
        {
            if (this.PointStation == null)
            {
                return;
            }

            AcGe.Point3d pntStart = new AcGe.Point3d(this.PointStation.E, this.PointStation.N, this.PointStation.H);
            AcGe.Point3d pntEnd   = new AcGe.Point3d(this.Coordinates.X, this.Coordinates.Y, 0);

            AcDb.Line line = new AcDb.Line(pntStart, pntEnd);
            line.Visible = this.Visible;

            AcGe.Point3d pntMiddle = new AcGe.LineSegment3d(pntStart, pntEnd).MidPoint;

            double angleTXT = line.Angle;

            if (angleTXT > Math.PI / 2 && angleTXT < Math.PI * 3 / 2)
            {
                angleTXT += Math.PI;
            }

            AcDb.MText text = new AcDb.MText();
            text.Contents = this.DistanceToString(AcRx.DistanceUnitFormat.Decimal) + "\r\n"
                            + "л.к. " + ServiceTable.FormatAngleValue(this.LeftlAngleToString(AcRx.AngularUnitFormat.DegreesMinutesSeconds));
            text.Rotation   = angleTXT;
            text.Location   = pntMiddle;
            text.Attachment = AcDb.AttachmentPoint.MiddleCenter;
            text.Width      = 25;
            text.TextHeight = 1.8 * this.ScaleDrawing;


            this.lineID = ServiceCAD.InsertObject(line);
            this.txtID  = ServiceCAD.InsertObject(text);
        }
Example #4
0
        public static bool InPoly(_AcGe.Point3d vertexPoint, _AcDb.Entity pElFG)
        {
            int nrTrue  = 0;
            int nrFalse = 0;

            if (InPoly(vertexPoint, 1.0, 1.0, pElFG))
            {
                nrTrue++;
            }
            else
            {
                nrFalse++;
            }

            if (InPoly(vertexPoint, -1.0, 1.0, pElFG))
            {
                nrTrue++;
            }
            else
            {
                nrFalse++;
            }

            if (InPoly(vertexPoint, -1.0, -1.0, pElFG))
            {
                nrTrue++;
            }
            else
            {
                nrFalse++;
            }

            return(nrTrue > nrFalse);
        }
Example #5
0
        private bool insertFormSide(_Ge.Point3d ptPos, double dir, double rotation)
        {
            _Ed.PromptStringOptions pStrOpts = new _Ed.PromptStringOptions("\nFormSide: ");
            pStrOpts.AllowSpaces = false;
            _Ed.PromptResult pStrRes = _c.ed.GetString(pStrOpts);
            string           result  = pStrRes.StringResult;

            if (pStrRes.Status == _Ed.PromptStatus.Cancel)
            {
                return(false);
            }

            _Ge.Point3d         insert = ptPos;
            _Db.AttachmentPoint a      = _Db.AttachmentPoint.BottomCenter;

            if (rotation == 0.0)
            {
                a = _Db.AttachmentPoint.BottomCenter;
                double newX = ptPos.X - (bigCircleOffset - bigCircleRadius) * dir / 2;
                double newY = ptPos.Y + textOffset;
                insert = new _Ge.Point3d(newX, newY, ptPos.Z);
            }
            else
            {
                a = _Db.AttachmentPoint.MiddleRight;
                double newX = ptPos.X - textOffset;
                double newY = ptPos.Y - (bigCircleOffset - bigCircleRadius) * dir / 2;
                insert = new _Ge.Point3d(newX, newY, ptPos.Z);
            }

            insertText(insert, a, result, 0);
            return(true);
        }
Example #6
0
        protected override AcEd.SamplerStatus Sampler(AcEd.JigPrompts prompts)
        {
            AcEd.JigPromptPointOptions jppo = new AcEd.JigPromptPointOptions();
            AcEd.PromptPointResult     ppr;

            jppo.Message      = this.methodConstructing.GetMessage();
            jppo.UseBasePoint = false;

            ppr = prompts.AcquirePoint(jppo);

            if (ppr.Status == AcEd.PromptStatus.Cancel || ppr.Status == AcEd.PromptStatus.Error)
            {
                return(AcEd.SamplerStatus.Cancel);
            }
            AcGe.Point3d tmpPt = ppr.Value.TransformBy(UCS.Inverse());
            if (!this.diagonalPoint.IsEqualTo(tmpPt, new AcGe.Tolerance(10e-10, 10e-10)))
            {
                this.diagonalPoint = tmpPt;
                return(AcEd.SamplerStatus.OK);
            }
            else
            {
                return(AcEd.SamplerStatus.NoChange);
            }
        }
Example #7
0
        private void insertLine(_Ge.Point3d ptPos, double dir, double rotation)
        {
            _Db.BlockTableRecord btr = _c.trans.GetObject(_c.modelSpace.Id, _Db.OpenMode.ForWrite) as _Db.BlockTableRecord;

            _Ge.Point3d ptEnd = new _Ge.Point3d();

            if (rotation == 0.0)
            {
                double newX = ptPos.X - (bigCircleOffset - bigCircleRadius) * dir;
                double newY = ptPos.Y;
                ptEnd = new _Ge.Point3d(newX, newY, ptPos.Z);
            }
            else
            {
                double newX = ptPos.X;
                double newY = ptPos.Y - (bigCircleOffset - bigCircleRadius) * dir;
                ptEnd = new _Ge.Point3d(newX, newY, ptPos.Z);
            }

            using (_Db.Line line = new _Db.Line(ptPos, ptEnd))
            {
                btr.AppendEntity(line);
                _c.trans.AddNewlyCreatedDBObject(line, true);
            }
        }
Example #8
0
        private bool getPoint(string prompt, _Ge.Point3d ptBase, ref _Ge.Point3d pt, ref bool finish)
        {
            _Ed.PromptPointOptions pPtOpts = new _Ed.PromptPointOptions("");
            pPtOpts.Keywords.Add("F");
            pPtOpts.Message      = prompt;
            pPtOpts.UseBasePoint = true;
            pPtOpts.BasePoint    = ptBase;

            _Ed.PromptPointResult pPtRes;
            pPtRes = _c.ed.GetPoint(pPtOpts);

            if (pPtRes.Status == _Ed.PromptStatus.Keyword)
            {
                _Ed.PromptPointOptions lastPtOpts = new _Ed.PromptPointOptions("");
                pPtOpts.Message      = "Last Point";
                pPtOpts.UseBasePoint = true;
                pPtOpts.BasePoint    = ptBase;

                pPtRes = _c.ed.GetPoint(lastPtOpts);
                pt     = pPtRes.Value;

                finish = true;
            }
            else if (pPtRes.Status == _Ed.PromptStatus.OK)
            {
                pt = pPtRes.Value;
            }
            else if (pPtRes.Status == _Ed.PromptStatus.Cancel)
            {
                return(false);
            }

            return(true);
        }
Example #9
0
        private void mainCreationLoop(List <_Area_v2> areas)
        {
            foreach (_Area_v2 area in areas)
            {
                string      name        = getAreaName(area);
                double      scale       = getAreaScale(area);
                _Ge.Point3d centerPoint = getAreaCenter(area);

                _Db.Layout lay = createLayoutandSetActive(name);
                //setLayoutPlotSettings(lay, "ISO_full_bleed_A3_(297.00_x_420.00_MM)", "monochrome.ctb", "DWG To PDF.pc3");
                setLayoutPlotSettings(lay, "PDFCreator", "A3", "monochrome.ctb");

                _Db.Viewport  vp  = layoutViewportGetter(lay);
                _Db.Extents2d ext = getMaximumExtents(lay);
                setViewportGeometry(vp, ext, 1.05);
                setViewportParameters(vp, scale, centerPoint);

                Dictionary <_Db.Layout, string> layouts = new Dictionary <_Db.Layout, string>();
                layouts[lay] = name;
                plotDriver(layouts);

                removeLayout(lay);
            }

            _c.ed.Regen();
        }
Example #10
0
        // Database extensions
        ///<summary>
        /// Create a piece of text of a specified size at a specified location.
        ///</summary>
        ///<param name="norm">The normal to the text object.</param>
        ///<param name="pt">The position for the text.</param>
        ///<param name="conts">The contents of the text.</param>
        ///<param name="size">The size of the text.</param>
        public static void CreateText(

            this _AcDb.Database db, _AcGe.Vector3d norm, _AcGe.Point3d pt, string conts, double size

            )
        {
            using (var tr = db.TransactionManager.StartTransaction())
            {
                var ms =
                    tr.GetObject(
                        _AcDb.SymbolUtilityServices.GetBlockModelSpaceId(db),
                        _AcDb.OpenMode.ForWrite

                        ) as _AcDb.BlockTableRecord;

                if (ms != null)
                {
                    var txt = new _AcDb.DBText();
                    txt.Normal         = norm;
                    txt.Position       = pt;
                    txt.Justify        = _AcDb.AttachmentPoint.MiddleCenter;
                    txt.AlignmentPoint = pt;
                    txt.TextString     = conts;
                    txt.Height         = size;

                    var id = ms.AppendEntity(txt);
                    tr.AddNewlyCreatedDBObject(txt, true);
                }

                tr.Commit();
            }
        }
Example #11
0
        internal void run()
        {
            List <_Db.BlockReference> viiteBlocks = getAllBlocks(blockNames);

            if (viiteBlocks.Count == 0)
            {
                string names = string.Join(", ", blockNames.ToArray());
                throw new DMTException("[ERROR] - (" + names + ") - not found");
            }

            List <Viide> viited             = getData(viiteBlocks);
            List <_Db.BlockReference> areas = getAllBlocks(areaName);

            if (areas.Count < 1)
            {
                _Ge.Point3d ip = getPoint();
                output(viited, ip);
            }
            else
            {
                Dictionary <_Db.BlockReference, List <Viide> > data = matchBlockToArea(areas, viited);

                foreach (_Db.BlockReference area in areas)
                {
                    output(data[area], area.GeometricExtents.MaxPoint);
                }
            }
        }
Example #12
0
        private void insertReinforcmentMark(string mark, G.Point IP)
        {
            string layerName = "K023TL";
            string styleName = "dmt_M" + (int)Math.Round(L._V_.Z_DRAWING_SCALE);

            textStyleHandler();
            blockHandler();
            leaderStyleHandler(styleName, (int)Math.Round(L._V_.Z_DRAWING_SCALE));

            _Db.DBDictionary mleaderStyleTable = _c.trans.GetObject(_c.db.MLeaderStyleDictionaryId, _Db.OpenMode.ForWrite) as _Db.DBDictionary;

            _Ge.Point3d insertPointLeader = new _Ge.Point3d(IP.X, IP.Y, 0);
            _Ge.Point3d insertPointText   = new _Ge.Point3d(IP.X + 7.5 * L._V_.Z_DRAWING_SCALE, IP.Y + 7.5 * L._V_.Z_DRAWING_SCALE, 0);

            _Db.MText mText = new _Db.MText();
            mText.SetDatabaseDefaults();
            mText.Contents = mark;

            _Db.MLeader leader = new _Db.MLeader();
            leader.SetDatabaseDefaults();
            leader.ContentType = _Db.ContentType.MTextContent;
            leader.MText       = mText;
            leader.AddLeaderLine(insertPointLeader);
            leader.TextLocation = insertPointText;
            leader.MLeaderStyle = mleaderStyleTable.GetAt(styleName);

            leader.Layer = layerName;

            _c.modelSpace.AppendEntity(leader);
            _c.trans.AddNewlyCreatedDBObject(leader, true);
        }
Example #13
0
        public BeamData(double height, double width, double maxlength, _AcGe.Point3d p0, _AcGe.Point3d p1, _AcGe.Point3d pSide = new _AcGe.Point3d())
        {
            BeamStartPoint = p0;
            BeamEndPoint   = p1;
            BeamSidePoint  = pSide;
            Height         = height;
            Width          = width;
            Length         = BeamStartPoint.GetVectorTo(BeamEndPoint).Length;
            MaxLength      = maxlength;

            if (Length > MaxLength)
            {
                MessageBox.Show("WARNING! - picked beam length is greater than maximum length for selected beam type.");
            }

            //
            // We need to check the incoming pSide var to see if we need to offset our beam to one side
            // or draw it on the centre line (the picked points form the centre line).
            //
            if (pSide.GetAsVector().Length == 0)
            {
                OffsetFactor = 0.5;     // no offset so set offset factor to half width to draw on centre line
            }
            else
            {
                OffsetFactor = 1.0;     // full offset required
            }
        }
Example #14
0
        // Helper functions to zoom using different techniques


        // Zoom using a view object


        private static void ZoomWin(

            _AcEd.Editor ed, _AcGe.Point3d min, _AcGe.Point3d max

            )
        {
            _AcGe.Point2d min2d = new _AcGe.Point2d(min.X, min.Y);

            _AcGe.Point2d max2d = new _AcGe.Point2d(max.X, max.Y);


            _AcDb.ViewTableRecord view =

                new _AcDb.ViewTableRecord();


            view.CenterPoint =

                min2d + ((max2d - min2d) / 2.0);

            view.Height = max2d.Y - min2d.Y;

            view.Width = max2d.X - min2d.X;

            ed.SetCurrentView(view);
        }
Example #15
0
        protected override AcEd.SamplerStatus Sampler(AcEd.JigPrompts jp)
        {
            AcEd.JigPromptPointOptions po = new AcEd.JigPromptPointOptions("\nВкажіть точку вставки:");

            po.UserInputControls =
                (AcEd.UserInputControls.Accept3dCoordinates |
                 AcEd.UserInputControls.NullResponseAccepted |
                 AcEd.UserInputControls.NoNegativeResponseAccepted |
                 AcEd.UserInputControls.GovernedByOrthoMode);

            AcEd.PromptPointResult ppr = jp.AcquirePoint(po);

            if (ppr.Status == AcEd.PromptStatus.Keyword)
            {
                return(AcEd.SamplerStatus.NoChange);
            }
            else if (ppr.Status == AcEd.PromptStatus.OK)
            {
                if (_location.DistanceTo(ppr.Value) < AcGe.Tolerance.Global.EqualPoint)
                {
                    return(AcEd.SamplerStatus.NoChange);
                }
                _location = ppr.Value;
                return(AcEd.SamplerStatus.OK);
            }
            return(AcEd.SamplerStatus.Cancel);
        }
Example #16
0
 ArraysBlocks()
 {
     this.NameBlock       = "";
     this.ScaleBlock      = 1;
     this.RotationBlock   = 0;
     this.BasePointArrays = AcGe.Point3d.Origin;
 }
Example #17
0
        private void createX(_Db.BlockTableRecord btr, double radius, _Ge.Point3d ip)
        {
            _Ge.Point2d p1 = new _Ge.Point2d(ip.X - radius, ip.Y);
            _Ge.Point2d p2 = new _Ge.Point2d(ip.X + radius, ip.Y);
            _Ge.Point2d p3 = new _Ge.Point2d(ip.X, ip.Y - radius);
            _Ge.Point2d p4 = new _Ge.Point2d(ip.X, ip.Y + radius);

            using (_Db.Polyline poly = new _Db.Polyline())
            {
                poly.AddVertexAt(0, p1, 0, 0, 0);
                poly.AddVertexAt(1, p2, 0, 0, 0);
                poly.ColorIndex = 2;

                btr.AppendEntity(poly);
                _c.trans.AddNewlyCreatedDBObject(poly, true);
            }

            using (_Db.Polyline poly = new _Db.Polyline())
            {
                poly.AddVertexAt(0, p3, 0, 0, 0);
                poly.AddVertexAt(1, p4, 0, 0, 0);
                poly.ColorIndex = 2;

                btr.AppendEntity(poly);
                _c.trans.AddNewlyCreatedDBObject(poly, true);
            }
        }
Example #18
0
        private void createBlock(_Ge.Point3d center)
        {
            if (!_c.blockTable.Has(blockName))
            {
                write("Create missing block");

                _Db.BlockTableRecord btr = new _Db.BlockTableRecord();
                btr.Name = blockName;

                _Db.ObjectId btrId = _c.blockTable.Add(btr);
                _c.trans.AddNewlyCreatedDBObject(btr, true);

                createX(btr, 1.5, new _Ge.Point3d(0, 0, 0));
                createCircle(btr, 1, new _Ge.Point3d(0, 0, 0));

                _Db.BlockReference newBlockReference = new _Db.BlockReference(center, btrId);
                newBlockReference.TransformBy(_Ge.Matrix3d.Scaling(40, center));

                _c.modelSpace.AppendEntity(newBlockReference);
                _c.trans.AddNewlyCreatedDBObject(newBlockReference, true);
            }
            else
            {
                using (_Db.BlockReference newBlockReference = new _Db.BlockReference(center, _c.blockTable[blockName]))
                {
                    newBlockReference.TransformBy(_Ge.Matrix3d.Scaling(40, center));
                    _c.modelSpace.AppendEntity(newBlockReference);
                    _c.trans.AddNewlyCreatedDBObject(newBlockReference, true);
                }
            }
        }
Example #19
0
        private void outputTable(_Area_v2 a, List <_Mark> rows)
        {
            _Db.DBObject currentEntity = _c.trans.GetObject(a.ID, _Db.OpenMode.ForWrite, false) as _Db.DBObject;

            if (currentEntity is _Db.BlockReference)
            {
                _Db.BlockReference blockRef = currentEntity as _Db.BlockReference;

                double scale = blockRef.ScaleFactors.X;
                string name  = blockRef.Name;


                _Ge.Point3d currentPoint = a.Start;

                if (name == newBoxNames[0])
                {
                    currentPoint = new _Ge.Point3d(a.Start.X + (366 * scale), a.Start.Y + (141.8 * scale), a.Start.Z);
                }
                else if (name == newBoxNames[1])
                {
                    currentPoint = new _Ge.Point3d(a.Start.X + (366 * scale), a.Start.Y + (263.5 * scale), a.Start.Z);
                }

                int counter = 0;
                foreach (_Mark r in rows)
                {
                    if (r.Position != "emptyrow")
                    {
                        double txtHeight = 1.5 * scale;

                        _Ge.Point3d position_IP = new _Ge.Point3d(currentPoint.X + (1 * scale), currentPoint.Y + (1.125 * scale), currentPoint.Z);
                        _Ge.Point3d diameter_IP = new _Ge.Point3d(currentPoint.X + (0.75 * scale) + (6.1 * scale), currentPoint.Y + (1.125 * scale), currentPoint.Z);
                        _Ge.Point3d number_IP   = new _Ge.Point3d(currentPoint.X + (1.5 * scale) + (9.75 * scale), currentPoint.Y + (1.125 * scale), currentPoint.Z);

                        insertText(r.Position, position_IP, _Mark.markLayerName, txtHeight);
                        insertText(r.Diameter.ToString(), diameter_IP, _Mark.markLayerName, txtHeight);
                        insertText(r.Number.ToString(), number_IP, _Mark.markLayerName, txtHeight);
                    }

                    if (counter == 19)
                    {
                        if (name == newBoxNames[0])
                        {
                            currentPoint = new _Ge.Point3d(a.Start.X + (336 * scale), a.Start.Y + (141.8 * scale), a.Start.Z);
                        }
                        else if (name == newBoxNames[1])
                        {
                            currentPoint = new _Ge.Point3d(a.Start.X + (336 * scale), a.Start.Y + (263.5 * scale), a.Start.Z);
                        }
                    }
                    else
                    {
                        currentPoint = new _Ge.Point3d(currentPoint.X, currentPoint.Y - (4 * scale), currentPoint.Z);
                    }

                    counter++;
                }
            }
        }
Example #20
0
        public static double GetProjectionOnLine(AcGe.Point3d startPointLine, AcGe.Point3d endPointLine, AcGe.Point3d point)
        {
            double dirAngleLine    = GetDirAngle(startPointLine, endPointLine);
            double dirAngleToPoint = GetDirAngle(startPointLine, point);
            double a = dirAngleToPoint - dirAngleLine;

            return(Math.Cos(a) * startPointLine.GetVectorTo(point).Convert2d(new AcGe.Plane()).Length);
        }
Example #21
0
        private _Ge.Point3d getCenter(_Db.Region reg)
        {
            _Db.Solid3d solid = new _Db.Solid3d();
            solid.Extrude(reg, 2.0, 0.0);
            _Ge.Point3d solidCentroid = solid.MassProperties.Centroid;

            return(new _Ge.Point3d(solidCentroid.X, solidCentroid.Y, 0));
        }
Example #22
0
 public CoordinatesRecordSDR(string namePoint, AcGe.Point3d point, string description)
 {
     this.NamePoint   = namePoint;
     this.Northing    = point.Y.ToString("0.000").Replace(",", ".");
     this.Easting     = point.X.ToString("0.000").Replace(",", ".");
     this.Elevation   = point.Z.ToString("0.000").Replace(",", ".");
     this.Description = description;
 }
Example #23
0
        public _Area_v1(_Ge.Point3d s, _Ge.Point3d e)
        {
            start = s;
            end   = e;

            reinf  = new _Ge.Point3d(e.X - 2180, e.Y - 1460, e.Z);
            weight = new _Ge.Point3d(e.X - 780, e.Y - 5062, e.Z);
        }
 public static AcDb.ObjectId InsertBlock(
     String nameBlock,
     AcGe.Point3d insertionPoint,
     double scale,
     double rotation)
 {
     return(InsertBlock(nameBlock, insertionPoint, scale, rotation, AcDb.ObjectId.Null, null));
 }
        // Returns whether the provided DB extents - retrieved from

        // Database.Extmin/max - are "valid" or whether they are the default

        // invalid values (where the min's coordinates are positive and the

        // max coordinates are negative)



        private bool ValidDbExtents(_AcGe.Point3d min, _AcGe.Point3d max)
        {
            return

                (!(min.X > 0 && min.Y > 0 && min.Z > 0 &&

                   max.X < 0 && max.Y < 0 && max.Z < 0));
        }
Example #26
0
        private void logic()
        {
            List <_Db.Dimension> wrongDims = new List <_Db.Dimension>();
            Dictionary <_Ge.Point3d, _Db.Dimension> wrongPoints = new Dictionary <_Ge.Point3d, _Db.Dimension>();

            foreach (_Db.Dimension dim in dims.Keys)
            {
                _Db.BlockTableRecord btr    = dims[dim];
                List <_Ge.Point3d>   points = getBlockTableRecordPoints(btr);

                if (dim is _Db.RotatedDimension)
                {
                    _Db.RotatedDimension rdim = dim as _Db.RotatedDimension;
                    _Ge.Point3d          p1   = rdim.XLine1Point;
                    _Ge.Point3d          p2   = rdim.XLine2Point;

                    bool pp1 = matchPoints(p1, points);
                    bool pp2 = matchPoints(p2, points);

                    if (pp1 == false)
                    {
                        wrongPoints[p1] = dim;
                        if (!wrongDims.Contains(dim))
                        {
                            wrongDims.Add(dim);
                        }
                    }
                    if (pp2 == false)
                    {
                        wrongPoints[p2] = dim;
                        if (!wrongDims.Contains(dim))
                        {
                            wrongDims.Add(dim);
                        }
                    }
                }
            }

            write("Vigade arv: " + wrongDims.Count().ToString());

            if (wrongDims.Count > 0)
            {
                initLayer(kontrollLayer);
            }

            foreach (_Db.Dimension dim in wrongDims)
            {
                changeFillColor(dim, 1);
            }

            foreach (_Ge.Point3d pt in wrongPoints.Keys)
            {
                _Db.Dimension dim = wrongPoints[pt];

                createCircle(100, 1, pt, dims[dim]);
                createCircle(750, 1, pt, dims[dim]);
            }
        }
Example #27
0
 public SettingTable()
 {
     this.KeyTable         = "NoKey";
     this.TypeTable        = Tables.TypeTable.TableBorderParcel;
     this.title            = "None";
     this.TextHeight       = 2;
     this.Columns          = new List <ColumnTable>();
     this.BasePointDrawing = AcGe.Point3d.Origin;
 }
 public static AcDb.ObjectId InsertBlock(
     string nameBlock,
     AcGe.Point3d insertionPoint,
     double scale,
     double rotation,
     Dictionary <string, string> tags)
 {
     return(InsertBlock(nameBlock, insertionPoint, scale, rotation, AcDb.ObjectId.Null, tags));
 }
Example #29
0
 public static AcDb.DBText CreateText(AcGe.Point3d insertPoint, string textValue)
 {
     AcDb.DBText text = new AcDb.DBText
     {
         TextString = textValue,
         Position   = insertPoint
     };
     return(text);
 }
Example #30
0
 ArraysBlocks(string nameBlock,
              double scaleBlock,
              double rotationBlock,
              AcGe.Point3d basePointArrays)
 {
     this.NameBlock       = nameBlock;
     this.ScaleBlock      = scaleBlock;
     this.RotationBlock   = rotationBlock;
     this.BasePointArrays = BasePointArrays;
 }