public ListBox () : base()
		{
			items = CreateItemCollection ();
			item_height = -1;
			selected_indices = new SelectedIndexCollection (this);
			selected_items = new SelectedObjectCollection (this);

			requested_height = bounds.Height;
			InternalBorderStyle = BorderStyle.Fixed3D;
			//BackColor = ThemeEngine.Current.ColorWindow;

			/* Vertical scrollbar */
			//TODO: add scroll event handler

			/* Horizontal scrollbar */
			//TODO: add scroll event handler

			/* Events */
			
			SetStyle (ControlStyles.UserPaint, false);

#if NET_2_0
			custom_tab_offsets = new IntegerCollection (this);
#endif
		}
Esempio n. 2
0
 public void MoveStretchPointsAt(IntegerCollection indices, Vector3d offset)
 {
     createInstance();
     BaseEntity.MoveStretchPointsAt(indices,offset);
     tr.Dispose();
 }
Esempio n. 3
0
 public void GetGripPoints(Point3dCollection gripPoints, IntegerCollection snapModes, IntegerCollection geometryIds)
 {
     createInstance();
     BaseEntity.GetGripPoints(gripPoints, snapModes,geometryIds);
     tr.Dispose();
 }
Esempio n. 4
0
 public override void GetObjectSnapPoints(Entity ent, ObjectSnapModes mode, IntPtr gsm, Point3d pick, Point3d last, Matrix3d view, Point3dCollection snaps, IntegerCollection geomIds, Matrix3d insertion)
 {
 }
Esempio n. 5
0
 public void AddRange(IntegerCollection value)
 {
     AddRangeInternal((ICollection)value);
 }
Esempio n. 6
0
 public override void GetObjectSnapPoints(Entity entity, ObjectSnapModes snapMode, IntPtr gsSelectionMark, Point3d pickPoint, Point3d lastPoint, Matrix3d viewTransform, Point3dCollection snapPoints, IntegerCollection geometryIds)
 {
     base.GetObjectSnapPoints(entity, snapMode, gsSelectionMark, pickPoint, lastPoint, viewTransform, snapPoints, geometryIds);
     if ((snapMode & ObjectSnapModes.ModeEnd) == ObjectSnapModes.ModeEnd)
     {
         Circle          c     = (Circle)entity;
         LineSegment3d[] lines = GetLines(c);
         foreach (LineSegment3d l in lines)
         {
             snapPoints.Add(l.StartPoint);
             snapPoints.Add(l.EndPoint);
         }
     }
 }
Esempio n. 7
0
 /// <inheritdoc />
 public override void GetObjectSnapPoints(Entity entity, ObjectSnapModes snapMode, IntPtr gsSelectionMark, Point3d pickPoint,
                                          Point3d lastPoint, Matrix3d viewTransform, Point3dCollection snapPoints, IntegerCollection geometryIds)
 {
     Debug.Print("WeldJointOsnapOverrule");
     if (IsApplicable(entity))
     {
         EntityUtils.OsnapOverruleProcess(entity, snapPoints);
     }
     else
     {
         base.GetObjectSnapPoints(entity, snapMode, gsSelectionMark, pickPoint, lastPoint, viewTransform, snapPoints, geometryIds);
     }
 }
    protected override bool WorldDrawData(WorldDraw draw)
    {
      if (!base.WorldDrawData(draw))
        return false;

      TransientManager ctm =
        TransientManager.CurrentTransientManager;
      IntegerCollection ints = new IntegerCollection();

      // Draw any outstanding segments (and do so only once)

      bool wasCalibrating = _calibrating;

      while (_lineSegs.Count > 0)
      {
        // Get the line segment and remove it from the list

        LineSegment3d ls = _lineSegs[0];
        _lineSegs.RemoveAt(0);

        // Create an equivalent, red, database line
        // (or yellow, if calibrating)

        Line ln = new Line(ls.StartPoint, ls.EndPoint);
        ln.ColorIndex = (wasCalibrating ? 2 : 1);
        _lines.Add(ln);

        // Draw it as transient graphics

        ctm.AddTransient(
          ln, TransientDrawingMode.DirectShortTerm,
          128, ints
        );

        _calibrating = false;
      }

      if (_drawing)
      {
        if (_cursor == null)
        {
          if (_vertices.Count > 0)
          {
            // Clear our skeleton

            ClearTransients();

            _curPt = _vertices[_vertices.Count - 1];

            // Make our sphere 10cm in diameter (5cm radius)

            Solid3d sol = new Solid3d();
            sol.CreateSphere(0.05);
            _cursor = sol;
            _cursor.TransformBy(
              Matrix3d.Displacement(_curPt - Point3d.Origin)
            );

            _cursor.ColorIndex = 2;

            ctm.AddTransient(
              _cursor, TransientDrawingMode.DirectShortTerm,
              128, ints
            );
          }
        }
        else
        {
          if (_vertices.Count > 0)
          {
            Point3d newPt = _vertices[_vertices.Count - 1];
            _cursor.TransformBy(
              Matrix3d.Displacement(newPt - _curPt)
            );
            _curPt = newPt;

            ctm.UpdateTransient(_cursor, ints);
          }
        }
      }
      else // !_drawing
      {
        if (_cursor != null)
        {
          ctm.EraseTransient(_cursor, ints);
          _cursor.Dispose();
          _cursor = null;
        }
      }

      return true;
    }
        protected override bool WorldDrawData(WorldDraw draw)
        {
            if (!base.WorldDrawData(draw))
            {
                return(false);
            }

            var ctm  = TransientManager.CurrentTransientManager;
            var ints = new IntegerCollection();

            while (_lineSegs.Count > 0)
            {
                // Get the line segment and remove it from the list

                var ls = _lineSegs[0];
                _lineSegs.RemoveAt(0);

                // Create an equivalent, red, database line
                // (or yellow, if calibrating)

                var ln = new Line(ls.StartPoint, ls.EndPoint);
                ln.ColorIndex = 1;
                _lines.Add(ln);

                // Draw it as transient graphics

                ctm.AddTransient(
                    ln, TransientDrawingMode.DirectShortTerm,
                    128, ints
                    );
            }

            if (_drawing)
            {
                if (_cursor == null)
                {
                    if (_vertices.Count > 0)
                    {
                        // Clear our skeleton

                        ClearTransients();

                        _curPt = _vertices[_vertices.Count - 1];

                        // Make our sphere 10cm in diameter (5cm radius)

                        var sol = new Solid3d();
                        sol.CreateSphere(0.05);
                        _cursor = sol;
                        _cursor.TransformBy(
                            Matrix3d.Displacement(_curPt - Point3d.Origin)
                            );

                        _cursor.ColorIndex = 2;

                        ctm.AddTransient(
                            _cursor, TransientDrawingMode.DirectShortTerm,
                            128, ints
                            );
                    }
                }
                else
                {
                    if (_vertices.Count > 0)
                    {
                        var newPt = _vertices[_vertices.Count - 1];
                        _cursor.TransformBy(
                            Matrix3d.Displacement(newPt - _curPt)
                            );
                        _curPt = newPt;

                        ctm.UpdateTransient(_cursor, ints);
                    }
                }
            }
            else // !_drawing
            {
                if (_cursor != null)
                {
                    ctm.EraseTransient(_cursor, ints);
                    _cursor.Dispose();
                    _cursor = null;
                }
            }

            return(true);
        }
Esempio n. 10
0
        public void Cmd_DimDelete()
        {
            var acCurDoc = Application.DocumentManager.MdiActiveDocument;
            var acCurDb  = acCurDoc.Database;
            var acCurEd  = acCurDoc.Editor;

            var prEntOpt = new PromptEntityOptions("\nSelect a dimension system to remove from: ");

            prEntOpt.SetRejectMessage("\nOnly linear dimensions may be selected.");
            prEntOpt.AllowNone = false;
            prEntOpt.AddAllowedClass(typeof(RotatedDimension), false);

            var prEntRes = acCurEd.GetEntity(prEntOpt);

            if (prEntRes.Status != PromptStatus.OK)
            {
                return;
            }

            var objId     = prEntRes.ObjectId;
            var delMatrix = acCurEd.GetAlignedMatrix();

            var eqPoint = CalcTol.ReturnCurrentTolerance();

            using (var acTrans = acCurDb.TransactionManager.StartTransaction())
            {
                var acEnt = acTrans.GetObject(objId, OpenMode.ForWrite) as Entity;
                if (acEnt != null)
                {
                    acEnt.Unhighlight();

                    var acRotDim = acEnt as RotatedDimension;
                    if (acRotDim != null)
                    {
                        var dimSys = DimSystem.GetSystem(acRotDim, eqPoint, eqPoint);

                        var prPtOpts =
                            new PromptPointOptions("\nSelect point to delete or press CTRL to start a crossing line: ");
                        PromptPointResult ptRes;

                        while (true)
                        {
                            if (dimSys.Count <= 0)
                            {
                                break;
                            }

                            dimSys.Highlight();

                            var nArray = DimSystem.GetActiveViewCount();

                            var ctManager = TransientManager.CurrentTransientManager;

                            var acCirc    = new Circle();
                            var acPreview = new Circle();
                            var acLine    = new Line(new Point3d(0, 0, 0), new Point3d(0, 0, 0));

                            acCirc.Color    = SettingsUser.DynPreviewColor;
                            acPreview.Color = SettingsUser.DynPreviewColor;
                            acLine.Color    = SettingsUser.DynPreviewColor;

                            var integerCollections = new IntegerCollection(nArray);

                            ctManager.AddTransient(acCirc, TransientDrawingMode.Main, 128,
                                                   integerCollections);
                            ctManager.AddTransient(acPreview, TransientDrawingMode.Main, 128,
                                                   integerCollections);
                            ctManager.AddTransient(acLine, TransientDrawingMode.Highlight, 128,
                                                   integerCollections);

                            var dPoints = dimSys.GetSystemPoints(eqPoint);

                            void PreviewHandler(object sender, PointMonitorEventArgs e)
                            {
                                var cdPoint = dimSys.GetNearest(e.Context.ComputedPoint, eqPoint);

                                var cPt     = dPoints[cdPoint];
                                var dlPoint = cPt.DimLinePoint;

                                acCirc.Center = dlPoint;

                                var scrSize = ScreenReader.GetSreenSize();

                                acCirc.Radius    = scrSize / 200;
                                acCirc.Normal    = acRotDim.Normal;
                                acPreview.Radius = scrSize / 200;
                                acPreview.Normal = acRotDim.Normal;

                                Point3d tempPt;
                                Point3d tempPt1;
                                Point3d tempPt2;

                                if (cPt.IsLast)
                                {
                                    tempPt = cPt.Dim1PointIndex != 1
                                        ? cPt.Dim1.XLine2Point
                                        : cPt.Dim1.XLine1Point;
                                    tempPt2 = tempPt;
                                }
                                else
                                {
                                    tempPt = cPt.Dim1PointIndex != 1
                                        ? cPt.Dim1.XLine2Point
                                        : cPt.Dim1.XLine1Point;
                                    tempPt1 = cPt.Dim2PointIndex != 1
                                        ? cPt.Dim2.XLine2Point
                                        : cPt.Dim2.XLine1Point;
                                    tempPt2 = dlPoint.DistanceTo(tempPt) <= dlPoint.DistanceTo(tempPt1)
                                        ? tempPt1
                                        : tempPt;
                                }

                                acLine.StartPoint = dlPoint;
                                acLine.EndPoint   = tempPt2;
                                acPreview.Center  = tempPt2;

                                ctManager.UpdateTransient(acCirc, integerCollections);
                                ctManager.UpdateTransient(acPreview, integerCollections);
                                ctManager.UpdateTransient(acLine, integerCollections);
                            }

                            acCurEd.PointMonitor += PreviewHandler;

                            try
                            {
                                ptRes = acCurEd.GetPoint(prPtOpts);
                            }
                            finally
                            {
                                acCurEd.PointMonitor -= PreviewHandler;

                                ctManager.EraseTransient(acCirc, integerCollections);
                                ctManager.EraseTransient(acPreview, integerCollections);
                                ctManager.EraseTransient(acLine, integerCollections);

                                acCirc.Dispose();
                                acPreview.Dispose();
                                acLine.Dispose();
                            }

                            #region CTRL Modifier

                            var ctrlPressed = (Control.ModifierKeys & Keys.Control) > Keys.None;

                            PromptPointResult promptPointResult = null;

                            if (ctrlPressed)
                            {
                                var promptPointOption1 =
                                    new PromptPointOptions("\nSelect second point of crossing line:")
                                {
                                    UseBasePoint  = true,
                                    UseDashedLine = true,
                                    BasePoint     = ptRes.Value
                                };

                                promptPointResult = acCurEd.GetPoint(promptPointOption1);

                                if (promptPointResult.Status != PromptStatus.OK)
                                {
                                    dimSys.Unhighlight();
                                    break;
                                }
                            }

                            if (ptRes.Status != PromptStatus.OK)
                            {
                                dimSys.Unhighlight();
                                break;
                            }

                            #endregion

                            if (ctrlPressed)
                            {
                                var delPt1 = ptRes.Value.TransformBy(delMatrix);
                                var delPt2 = promptPointResult.Value.TransformBy(delMatrix);
                                dimSys.Delete(delPt1, delPt2);
                            }
                            else
                            {
                                dimSys.Delete(ptRes.Value.TransformBy(delMatrix));
                            }
                        }

                        dimSys.Unhighlight();
                    }
                }

                acTrans.Commit();
            }
        }
 public void AddRange(IntegerCollection value)
 {
 }
Esempio n. 12
0
    public void TestMethod()
    {
        Document activeDoc = Application.DocumentManager.MdiActiveDocument;
        Database db        = activeDoc.Database;
        Editor   ed        = activeDoc.Editor;

        PromptEntityOptions peo = new PromptEntityOptions("Select a polyline : ");

        peo.SetRejectMessage("Not a polyline");
        peo.AddAllowedClass(typeof(Autodesk.AutoCAD.DatabaseServices.Polyline), true);

        PromptEntityResult per = ed.GetEntity(peo);

        if (per.Status != PromptStatus.OK)
        {
            return;
        }

        ObjectId plOid = per.ObjectId;

        PromptPointResult ppr = ed.GetPoint(new PromptPointOptions("Select an internal point : "));

        if (ppr.Status != PromptStatus.OK)
        {
            return;
        }

        Point3d testPoint = ppr.Value;

        PromptAngleOptions pao

            = new PromptAngleOptions("Specify ray direction");

        pao.BasePoint = testPoint;

        pao.UseBasePoint = true;

        PromptDoubleResult rayAngle = ed.GetAngle(pao);

        if (rayAngle.Status != PromptStatus.OK)
        {
            return;
        }
        Point3d tempPoint = testPoint.Add(Vector3d.XAxis);

        tempPoint = tempPoint.RotateBy(rayAngle.Value, Vector3d.ZAxis, testPoint);

        Vector3d rayDir = tempPoint - testPoint;

        ClearTransientGraphics();
        _markers = new DBObjectCollection();
        using (Transaction tr = db.TransactionManager.StartTransaction())
        {
            Curve plcurve = tr.GetObject(plOid, OpenMode.ForRead) as Curve;

            for (int cnt = 0; cnt < 2; cnt++)
            {
                if (cnt == 1)
                {
                    rayDir = rayDir.Negate();
                }

                using (Ray ray = new Ray())
                {
                    ray.BasePoint = testPoint;

                    ray.UnitDir = rayDir;
                    Point3dCollection intersectionPts = new Point3dCollection();

                    plcurve.IntersectWith(ray, Intersect.OnBothOperands, intersectionPts, IntPtr.Zero, IntPtr.Zero);

                    foreach (Point3d pt in intersectionPts)
                    {
                        Circle marker = new Circle(pt, Vector3d.ZAxis, 0.2);
                        marker.Color = Autodesk.AutoCAD.Colors.Color.FromRgb(0, 255, 0);
                        _markers.Add(marker);

                        IntegerCollection intCol = new IntegerCollection();

                        TransientManager tm = TransientManager.CurrentTransientManager;
                        tm.AddTransient(marker, TransientDrawingMode.Highlight, 128, intCol);

                        ed.WriteMessage("\n" + pt.ToString());
                    }
                }
            }

            tr.Commit();
        }
    }
Esempio n. 13
0
 public void AddRange(IntegerCollection value)
 {
     throw null;
 }
Esempio n. 14
0
        private static void InsertSampleUsersAndRoles()
        {
            // Get list of all album IDs
            List<int> albumIds = new List<int>();
            foreach (IGalleryServerRole role in RoleController.GetGalleryServerRoles())
            {
                if (role.RoleName == "System Administrator")
                {
                    albumIds.AddRange(role.AllAlbumIds);
                    albumIds.Sort();
                }
            }

            //// Create roles and assign each one to a random album
            Random rdm = new Random();
            const int numRoles = 100;
            for (int i = 0; i < numRoles; i++)
            {
                int albumId;
                do
                {
                    albumId = rdm.Next(albumIds[0], albumIds[albumIds.Count - 1]);
                } while (!albumIds.Contains(albumId));

                IIntegerCollection roleAlbums = new IntegerCollection();
                roleAlbums.Add(albumId);
                RoleController.CreateRole("Role " + i, true, false, true, false, true, false, true, false, true, false, false, false, roleAlbums);
            }

            // Create users and assign to random number of roles.
            const int numUsers = 100;
            for (int i = 0; i < numUsers; i++)
            {
                int numRolesToAssignToUser = rdm.Next(0, 5); // Add up to 5 roles to user
                List<String> roleNames = new List<string>(numRolesToAssignToUser);
                for (int j = 0; j < numRolesToAssignToUser; j++)
                {
                    // Pick a random role
                    string roleName = "Role " + rdm.Next(0, numRoles - 1);
                    if (!roleNames.Contains(roleName))
                        roleNames.Add(roleName);
                }

                string userName = "******" + i;
                if (UserController.GetUser(userName, false) == null)
                {
                    UserController.CreateUser(userName, "111", String.Empty, roleNames.ToArray(), false, 1);
                }
            }
        }
Esempio n. 15
0
                public override void MoveGripPointsAt(Entity entity, IntegerCollection indices, Vector3d offset)
                {
                    base.MoveGripPointsAt(entity, indices, offset);

                    if (Gripindex != null || GripIndexs[0] != null && GripIndexs[1] != null)
                    {
                        Polyline pLine = tr.openObject(DimInc_pLine, OpenMode.ForWrite) as Polyline;
                        if (pLine != null) {
                            Point3dCollection points = new Point3dCollection();
                            for (int i = 0; i < pLine.NumberOfVertices; i++)
                            {
                                if (i == Gripindex)
                                {
                                    points.Add(CurrPoint);
                                    continue;
                                }
                                else if (i == GripIndexs[0] || i == GripIndexs[1])
                                {
                                    points.Add(acMath.getPointAtVector(pLine.GetPoint3dAt(i),offset));
                                    continue;
                                }
                                else
                                {
                                    points.Add(pLine.GetPoint3dAt(i));
                                }
                            }
                            tr.closeObject();

                            Group Texts = tr.openGroup(DimInc_texts, OpenMode.ForWrite);
                            ObjectId[] ids = Texts.GetAllEntityIds();
                            tr.closeGroup();

                            int index = 0;
                            foreach (ObjectId id in ids)
                            {

                                DBText txt = tr.openObject(id, OpenMode.ForWrite) as DBText;
                                if (index != points.Count - 1)
                                {
                                    txt.TextString = acMath.totalDistance(points, DIMset.DimUnit_Precision, index).ToString();
                                    txt.Rotation = acMath.RetriveRot(points[index], points[index + 1]);
                                    txt.AlignmentPoint = acMath.pointOffset(points[index],points[index + 1],DIMset.Dimtxt_Offset)[1];
                                }
                                else
                                {
                                    txt.TextString = acMath.totalDistance(points, DIMset.DimUnit_Precision, index).ToString();
                                    txt.Rotation = acMath.RetriveRot(points[index], points[0]);
                                    txt.AlignmentPoint = acMath.pointOffset(points[index], points[0], DIMset.Dimtxt_Offset)[1];
                                }
                                tr.closeObject();
                                index++;
                            }

                            needRefresh = true;
                        }
                    }
                }
Esempio n. 16
0
			public void AddRange (IntegerCollection value)
			{
				AddItems (value);
			}
Esempio n. 17
0
 /// <include file='doc\ListBox.uex' path='docs/doc[@for="ListBox.IntegerCollection.AddRange1"]/*' />
 /// <devdoc>
 ///    <para>[To be supplied.]</para>
 /// </devdoc>
 public void AddRange(IntegerCollection value) {
     AddRangeInternal((ICollection)value);
 }
Esempio n. 18
0
 public override void GetObjectSnapPoints(Entity ent, ObjectSnapModes mode, IntPtr gsm, Point3d pick, Point3d last, Matrix3d view, Point3dCollection snaps, IntegerCollection geomIds, Matrix3d insertion)
 {
 }
	public void AddRange(IntegerCollection value) {}
Esempio n. 20
0
        public void CreatingABlock()
        {
            // Get the current database and start a transaction
            Document zwDoc   = Application.DocumentManager.MdiActiveDocument;
            Database zwCurDb = zwDoc.Database;
            Editor   ed      = zwDoc.Editor;

            //Database zwCurDb;
            //zwCurDb = Application.DocumentManager.MdiActiveDocument.Database;

            TypedValue[] zwTypValAr = new TypedValue[1];
            zwTypValAr.SetValue(new TypedValue((int)DxfCode.Color, 256), 0);
            SelectionFilter zwSelFtr = new SelectionFilter(zwTypValAr);

            PromptDoubleOptions XValue = new PromptDoubleOptions("");

            XValue.Message       = "\nEnter X scale: ";
            XValue.AllowZero     = false;
            XValue.AllowNone     = false;
            XValue.AllowNegative = false;
            PromptDoubleResult XValRes = ed.GetDouble(XValue);

            PromptDoubleOptions YValue = new PromptDoubleOptions("");

            YValue.Message       = "\nEnter Y scale: ";
            YValue.AllowZero     = false;
            YValue.AllowNone     = false;
            YValue.AllowNegative = false;
            PromptDoubleResult YValRes = ed.GetDouble(YValue);

            PromptSelectionResult zwSSPrompt = zwDoc.Editor.GetSelection(zwSelFtr);

            using (Transaction zwTrans = zwCurDb.TransactionManager.StartTransaction())
            {
                //open the Layer Tabel for read
                LayerTable zwLyrTbl;
                zwLyrTbl = zwTrans.GetObject(zwCurDb.LayerTableId, OpenMode.ForRead) as LayerTable;

                if (zwLyrTbl.Has("D0-XYLogo"))
                {
                    string zwLayerName = "D0-XYLogo";
                    Application.ShowAlertDialog("Layer exist! Change layer success.");
                    zwCurDb.Clayer = zwLyrTbl[zwLayerName];
                }
                else
                {
                    string           zwLayerName = "D0-XYLogo";
                    LayerTableRecord zwLyrTblRec = new LayerTableRecord();
                    zwLyrTblRec.Color    = Color.FromColorIndex(ColorMethod.ByAci, 3);
                    zwLyrTblRec.Name     = zwLayerName;
                    zwLyrTblRec.IsLocked = true;

                    zwLyrTbl.UpgradeOpen();
                    zwLyrTbl.Add(zwLyrTblRec);
                    zwTrans.AddNewlyCreatedDBObject(zwLyrTblRec, true);

                    zwCurDb.Clayer = zwLyrTbl[zwLayerName];
                    //Application.ShowAlertDialog("Layer does not exist!");
                }


                // Open the Block table for read
                BlockTable zwBlkTbl;
                zwBlkTbl = zwTrans.GetObject(zwCurDb.BlockTableId, OpenMode.ForRead) as BlockTable;

                ObjectId blkRecId = ObjectId.Null;

                if (!zwBlkTbl.Has("DWG-XYLogo"))
                {
                    using (BlockTableRecord zwBlkTblRec = new BlockTableRecord())
                    {
                        zwBlkTblRec.Name = "DWG-XYLogo";

                        // Set the insertion point for the block
                        zwBlkTblRec.Origin = new Point3d(0, 0, 0);

                        // Add a circle to the block
                        // using (Circle acCirc = new Circle())
                        {
                            //Create Line
                            Line zwLine_1 = new Line(new Point3d(-1, -1, 0),
                                                     new Point3d(8, -1, 0));
                            Line zwLine_2 = new Line(new Point3d(8, -1, 0),
                                                     new Point3d(8, 1, 0));
                            Line zwLine_3 = new Line(new Point3d(8, 1, 0),
                                                     new Point3d(1, 1, 0));
                            Line zwLine_4 = new Line(new Point3d(1, 1, 0),
                                                     new Point3d(1, 8, 0));
                            Line zwLine_5 = new Line(new Point3d(1, 8, 0),
                                                     new Point3d(-1, 8, 0));
                            Line zwLine_6 = new Line(new Point3d(-1, 8, 0),
                                                     new Point3d(-1, -1, 0));
                            Line zwLine_7 = new Line(new Point3d(-1, -1, 0),
                                                     new Point3d(1, 1, 0));

                            //Arrow_Horizontal
                            Line zwLine_11 = new Line(new Point3d(8, 0, 0),
                                                      new Point3d(13, 0, 0));
                            Line zwLine_12 = new Line(new Point3d(13, 0, 0),
                                                      new Point3d(10, 0.8, 0));
                            Line zwLine_13 = new Line(new Point3d(13, 0, 0),
                                                      new Point3d(10, -0.8, 0));

                            //Arrow_Vertical
                            Line zwLine_21 = new Line(new Point3d(0, 8, 0),
                                                      new Point3d(0, 13, 0));
                            Line zwLine_22 = new Line(new Point3d(0, 13, 0),
                                                      new Point3d(-0.8, 10, 0));
                            Line zwLine_23 = new Line(new Point3d(0, 13, 0),
                                                      new Point3d(0.8, 10, 0));

                            //Create Text
                            DBText Text_X_Scale = new DBText();
                            Text_X_Scale.SetDatabaseDefaults();
                            Text_X_Scale.Position   = new Point3d(1, -0.5, 0);
                            Text_X_Scale.Height     = 0.7;
                            Text_X_Scale.TextString = string.Format("X = {0}", XValRes.Value.ToString());

                            DBText Text_Y_Scale = new DBText();
                            Text_Y_Scale.SetDatabaseDefaults();
                            Text_Y_Scale.Position   = new Point3d(0.5, 1, 0);
                            Text_Y_Scale.Height     = 0.7;
                            Text_Y_Scale.Rotation   = 1.571;
                            Text_Y_Scale.TextString = string.Format("Y = {0}", YValRes.Value.ToString());

                            zwLine_1.SetDatabaseDefaults();
                            zwLine_2.SetDatabaseDefaults();
                            zwLine_3.SetDatabaseDefaults();
                            zwLine_4.SetDatabaseDefaults();
                            zwLine_5.SetDatabaseDefaults();
                            zwLine_6.SetDatabaseDefaults();
                            zwLine_7.SetDatabaseDefaults();

                            zwLine_11.SetDatabaseDefaults();
                            zwLine_12.SetDatabaseDefaults();
                            zwLine_13.SetDatabaseDefaults();

                            zwLine_21.SetDatabaseDefaults();
                            zwLine_22.SetDatabaseDefaults();
                            zwLine_23.SetDatabaseDefaults();

                            //Add object to Block Table record and the transaction
                            zwBlkTblRec.AppendEntity(Text_X_Scale);

                            zwBlkTblRec.AppendEntity(Text_Y_Scale);

                            zwBlkTblRec.AppendEntity(zwLine_1);
                            zwBlkTblRec.AppendEntity(zwLine_2);
                            zwBlkTblRec.AppendEntity(zwLine_3);
                            zwBlkTblRec.AppendEntity(zwLine_4);
                            zwBlkTblRec.AppendEntity(zwLine_5);
                            zwBlkTblRec.AppendEntity(zwLine_6);
                            zwBlkTblRec.AppendEntity(zwLine_7);
                            zwBlkTblRec.AppendEntity(zwLine_11);
                            zwBlkTblRec.AppendEntity(zwLine_12);
                            zwBlkTblRec.AppendEntity(zwLine_13);
                            zwBlkTblRec.AppendEntity(zwLine_21);
                            zwBlkTblRec.AppendEntity(zwLine_22);
                            zwBlkTblRec.AppendEntity(zwLine_23);
                            zwBlkTbl.UpgradeOpen();
                            zwBlkTbl.Add(zwBlkTblRec);
                            zwTrans.AddNewlyCreatedDBObject(zwBlkTblRec, true);

                            string zwLayer0 = "0";
                            zwCurDb.Clayer   = zwLyrTbl[zwLayer0];
                            ; zwCurDb.Clayer = zwLyrTbl["Defpoints"];
                        }
                        blkRecId = zwBlkTblRec.Id;
                    }
                }
                else
                {
                    //blkRecId = zwBlkTbl["DWG-XYLogo"];
                    string zwLayer0 = "0";
                    zwCurDb.Clayer = zwLyrTbl[zwLayer0];
                    ed.WriteMessage("Block already exist. Program stop.");
                    Application.ShowAlertDialog("Block already exist. Program stop.");
                    //Environment.Exit(-1);
                    //Application.Quit();
                }

                if (blkRecId != ObjectId.Null)
                {
                    using (BlockReference zwBlkRef = new BlockReference(new Point3d(0, 0, 0), blkRecId))
                    {
                        BlockTableRecord zwCurSpaceBlkTblRec;
                        zwCurSpaceBlkTblRec = zwTrans.GetObject(zwCurDb.CurrentSpaceId, OpenMode.ForWrite) as BlockTableRecord;

                        zwCurSpaceBlkTblRec.AppendEntity(zwBlkRef);
                        zwTrans.AddNewlyCreatedDBObject(zwBlkRef, true);
                    }
                }

                //PromptSelectionResult zwSSPrompt = zwDoc.Editor.GetSelection(zwSelFtr);
                if (zwSSPrompt.Status == PromptStatus.OK)
                {
                    SelectionSet zwSSet = zwSSPrompt.Value;
                    //Application.ShowAlertDialog(zwSSet.Count.ToString());
                    IntegerCollection[] test = new IntegerCollection[zwSSet.Count];
                    BlockTable          zwBlkTbl2;
                    zwBlkTbl2 = zwTrans.GetObject(zwCurDb.BlockTableId, OpenMode.ForWrite) as BlockTable;

                    BlockTableRecord zwBlkTblRec2;
                    zwBlkTblRec2 = zwTrans.GetObject(zwBlkTbl2[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;

                    foreach (var item in zwSSet)
                    {
                        CrossingOrWindowSelectedObject currentObject = item as CrossingOrWindowSelectedObject;
                        if (currentObject != null)
                        {
                            try
                            {
                                BlockReference blockRef = zwTrans.GetObject(currentObject.ObjectId, OpenMode.ForWrite) as BlockReference;
                                if (blockRef != null)
                                {
                                    Point3d  oldPoint  = new Point3d(new double[] { blockRef.Position.X, blockRef.Position.Y, blockRef.Position.Z });
                                    Vector3d newVector = oldPoint.GetVectorTo(new Point3d(new double[] { blockRef.Position.X * 1.1, blockRef.Position.Y * 1.7, blockRef.Position.Z }));
                                    blockRef.TransformBy(Matrix3d.Displacement(newVector));
                                    Point3d newPoint = new Point3d(new double[] { blockRef.Position.X * 1.1, blockRef.Position.Y * 1.7, blockRef.Position.Z });
                                    zwTrans.AddNewlyCreatedDBObject(blockRef, true);
                                }
                            }
                            catch (System.Exception ex)
                            {
                                System.Diagnostics.Trace.WriteLine(ex);
                            }
                        }
                        else
                        {
                            Application.ShowAlertDialog("Empty");
                        }
                    }
                }



                // Save the new object to the database
                zwTrans.Commit();

                // Dispose of the transaction
            }
        }
Esempio n. 21
0
        //This function is called from point Monitor recator call back "ed_PointMonitor".
        //This function has a object id as a parameter. Depending of value of passed
        //object id, this function adds or modifies Transient Graphics
        static void AddOrModifyTGPoints(ObjectId id)
        {
            //Passed entity is same as entity to which point list is present in TGpoints
            if (m_currentId == id)
            {
                modifyTGPoints();
                return;
            }


            eraseTGPoints();

            Point3dCollection pointList   = new Point3dCollection();
            IntegerCollection colloection = new IntegerCollection();

            Transaction trans = Application.DocumentManager.MdiActiveDocument.Database.TransactionManager.StartTransaction();

            try
            {
                m_currentId = id;


                //memory given to point array is still present and user has moved the mouse over
                //a new entity, means we need to recreate the point array, so delete the current
                //point arry
                DisposePointArray();


                // now open the entity below cursor for read
                Entity ent = (Entity)trans.GetObject(id, OpenMode.ForRead);
                // if ok

                //prepare the point list
                if (Line.GetClass(typeof(Line)) == ent.GetRXClass())
                {
                    Line line = (Line)ent;
                    BreakLine(ref line, ref pointList);
                }
                else if (Arc.GetClass(typeof(Arc)) == ent.GetRXClass())
                {
                    Arc arc = (Arc)ent;
                    BreakArc(ref arc, ref pointList);
                }
                else if (Polyline.GetClass(typeof(Polyline)) == ent.GetRXClass())
                {
                    Polyline pline = (Polyline)ent;
                    BreakPolyLine(ref pline, ref pointList);
                }

                trans.Commit();
            }
            finally
            {
                // close everything up
                trans.Dispose();
            }

            //create DBPoint array... DBPoints are used as "Transient entity"
            if (pointList.Count != 0)
            {
                AddTransientGraphics();
            }
        }
Esempio n. 22
0
        public void Cmd_DimMove()
        {
            var acCurDoc = Application.DocumentManager.MdiActiveDocument;
            var acCurDb  = acCurDoc.Database;
            var acCurEd  = acCurDoc.Editor;

            var prEntOpt = new PromptEntityOptions("\nSelect a dimension system to move: ");

            prEntOpt.SetRejectMessage("\nOnly linear dimensions may be selected.");
            prEntOpt.AllowNone = false;
            prEntOpt.AddAllowedClass(typeof(RotatedDimension), false);

            var prEntRes = acCurEd.GetEntity(prEntOpt);

            if (prEntRes.Status != PromptStatus.OK)
            {
                return;
            }

            var objId     = prEntRes.ObjectId;
            var addMatrix = acCurEd.GetAlignedMatrix();

            var eqPoint = CalcTol.ReturnCurrentTolerance();

            using (var acTrans = acCurDb.TransactionManager.StartTransaction())
            {
                var acEnt = acTrans.GetObject(objId, OpenMode.ForWrite) as Entity;
                if (acEnt != null)
                {
                    acEnt.Unhighlight();

                    var acRotDim = acEnt as RotatedDimension;
                    if (acRotDim != null)
                    {
                        var dimSys = DimSystem.GetSystem(acRotDim, eqPoint, eqPoint);

                        var prPtOpts =
                            new PromptPointOptions("\nSelect new position for dimensions: ");

                        while (true)
                        {
                            dimSys.Highlight();

                            var nArray            = DimSystem.GetActiveViewCount();
                            var ctManager         = TransientManager.CurrentTransientManager;
                            var intCol            = new IntegerCollection(nArray);
                            var rotatedDimensions = new List <RotatedDimension>();

                            foreach (var dim in dimSys.SysList)
                            {
                                var dimClone = (RotatedDimension)dim.Clone();
                                ctManager.AddTransient(dimClone, TransientDrawingMode.Highlight, 128, intCol);
                                rotatedDimensions.Add(dimClone);
                            }

                            void Handler(object sender, PointMonitorEventArgs e)
                            {
                                foreach (var tDim in rotatedDimensions)
                                {
                                    if (!tDim.UsingDefaultTextPosition)
                                    {
                                        var dimLinePoint = tDim.DimLinePoint;
                                        var textPosition = tDim.TextPosition;
                                        tDim.DimLinePoint = e.Context.ComputedPoint;
                                        ctManager.UpdateTransient(tDim, intCol);
                                        tDim.TextPosition =
                                            textPosition.Add(dimLinePoint.GetVectorTo(tDim.DimLinePoint));
                                    }
                                    else
                                    {
                                        tDim.DimLinePoint = e.Context.ComputedPoint;
                                    }

                                    ctManager.UpdateTransient(tDim, intCol);
                                }
                            }

                            acCurEd.PointMonitor += Handler;
                            PromptPointResult prRes;

                            try
                            {
                                prRes = acCurEd.GetPoint(prPtOpts);
                            }
                            finally
                            {
                                acCurEd.PointMonitor -= Handler;

                                foreach (var acRotRim in rotatedDimensions)
                                {
                                    ctManager.EraseTransient(acRotRim, intCol);
                                    acRotRim.Dispose();
                                }
                            }

                            if (prRes.Status != PromptStatus.OK)
                            {
                                break;
                            }

                            dimSys.MoveSystem(prRes.Value.TransformBy(addMatrix), eqPoint);
                            acTrans.TransactionManager.QueueForGraphicsFlush();
                        }

                        dimSys.Unhighlight();
                    }
                }

                acTrans.Commit();
            }
        }
Esempio n. 23
0
        public void Cmd_DimExtend()
        {
            if (!LicensingAgent.Check())
            {
                return;
            }
            var acCurDoc = Application.DocumentManager.MdiActiveDocument;
            var acCurDb  = acCurDoc.Database;
            var acCurEd  = acCurDoc.Editor;

            var prEntOpt = new PromptEntityOptions("\nSelect a dimension system to extend: ");

            prEntOpt.SetRejectMessage("\nOnly linear dimensions may be selected.");
            prEntOpt.AllowNone = false;
            prEntOpt.AddAllowedClass(typeof(RotatedDimension), false);

            var prEntRes = acCurEd.GetEntity(prEntOpt);

            if (prEntRes.Status != PromptStatus.OK)
            {
                return;
            }

            var objId    = prEntRes.ObjectId;
            var matrix3d = acCurEd.GetAlignedMatrix();

            var eqPoint = CalcTol.ReturnCurrentTolerance();

            using (var acTrans = acCurDb.TransactionManager.StartTransaction())
            {
                var acEnt = acTrans.GetObject(objId, OpenMode.ForWrite) as Entity;
                if (acEnt != null)
                {
                    acEnt.Unhighlight();

                    var acRotDim = acEnt as RotatedDimension;
                    if (acRotDim != null)
                    {
                        var dimSys = DimSystem.GetSystem(acRotDim, eqPoint, eqPoint);

                        dimSys.Highlight();

                        var promptPointOption2 =
                            new PromptPointOptions(
                                "\nSelect a dimension line to extend or press CTRL to start crossing line:");

                        while (true)
                        {
                            if (dimSys.Count == 0)
                            {
                                break;
                            }

                            dimSys.Highlight();

                            var nArray    = DimSystem.GetActiveViewCount();
                            var ctManager = TransientManager.CurrentTransientManager;

                            var acCirc = new Circle();
                            var acLine = new Line(new Point3d(0, 0, 0), new Point3d(0, 0, 0));

                            acCirc.Color  = SettingsUser.DynPreviewColor;
                            acCirc.Normal = acRotDim.Normal;

                            acLine.Color = SettingsUser.DynPreviewColor;

                            var intCol = new IntegerCollection(nArray);

                            ctManager.AddTransient(acCirc, TransientDrawingMode.Highlight, 128,
                                                   intCol);
                            ctManager.AddTransient(acLine, TransientDrawingMode.Highlight, 128,
                                                   intCol);

                            var sysPts = dimSys.GetSystemPoints(eqPoint);

                            void Handler(object sender, PointMonitorEventArgs e)
                            {
                                var cPt     = dimSys.GetNearest(e.Context.ComputedPoint, eqPoint);
                                var sysPt   = sysPts[cPt];
                                var dlPt    = sysPt.DimLinePoint;
                                var scrSize = ScreenReader.GetSreenSize();

                                acCirc.Radius = scrSize / 200;

                                var point3d = sysPt.Dim1PointIndex != 1
                                    ? sysPt.Dim1.XLine2Point
                                    : sysPt.Dim1.XLine1Point;

                                if (Math.Abs(point3d.DistanceTo(dlPt)) <= eqPoint)
                                {
                                    acCirc.Center     = dlPt;
                                    acLine.StartPoint = dlPt;
                                    acLine.EndPoint   = dlPt;
                                    ctManager.UpdateTransient(acCirc, intCol);
                                    ctManager.UpdateTransient(acLine, intCol);
                                    return;
                                }

                                var point = new Line3d(dlPt, point3d).GetClosestPointTo(e.Context.ComputedPoint).Point;

                                acLine.StartPoint = dlPt;
                                acLine.EndPoint   = point;
                                acCirc.Center     = point;
                                ctManager.UpdateTransient(acCirc, intCol);
                                ctManager.UpdateTransient(acLine, intCol);
                            }

                            acCurEd.PointMonitor += Handler;

                            PromptPointResult ptRes;
                            try
                            {
                                ptRes = acCurDoc.Editor.GetPoint(promptPointOption2);
                            }
                            finally
                            {
                                acCurEd.PointMonitor -= Handler;
                                ctManager.EraseTransient(acCirc, intCol);
                                ctManager.EraseTransient(acLine, intCol);
                                acCirc.Dispose();
                                acLine.Dispose();
                            }

                            var cntrlPressed = (Control.ModifierKeys & Keys.Control) > Keys.None;

                            PromptPointResult ctrlRes = null;
                            if (cntrlPressed)
                            {
                                var promptPointOption3 =
                                    new PromptPointOptions("\nSelect second point of crossing line:")
                                {
                                    UseBasePoint  = true,
                                    UseDashedLine = true,
                                    BasePoint     = ptRes.Value
                                };

                                ctrlRes = acCurDoc.Editor.GetPoint(promptPointOption3);
                                if (ctrlRes.Status != PromptStatus.OK)
                                {
                                    break;
                                }
                            }

                            if (ptRes.Status != PromptStatus.OK)
                            {
                                break;
                            }

                            if (cntrlPressed)
                            {
                                var point3d6 = ptRes.Value.TransformBy(matrix3d);
                                var point3d7 = ctrlRes.Value.TransformBy(matrix3d);
                                var nums     = dimSys.GetSystemByLine(point3d6, point3d7, eqPoint);

                                if (nums.Count <= 0)
                                {
                                    continue;
                                }

                                var sysPoints2 = dimSys.GetSystemPoints(eqPoint);
                                foreach (var num3 in nums)
                                {
                                    var point3d8 = DimSystem.GetCrossing(dimSys, sysPoints2, num3, point3d6,
                                                                         point3d7, eqPoint);
                                    if (point3d8.X != -99999 || point3d8.Y != -99999 || point3d8.Z != -99999)
                                    {
                                        dimSys.Extend(num3, 0, point3d8, eqPoint);
                                    }
                                    else
                                    {
                                        acCurEd.WriteMessage("\nCannot extend lines with zero length.");
                                    }
                                }

                                acTrans.TransactionManager.QueueForGraphicsFlush();
                            }
                            else
                            {
                                var point3d9  = ptRes.Value.TransformBy(matrix3d);
                                var num4      = dimSys.GetNearest(point3d9, eqPoint);
                                var sysPoint  = dimSys.GetSystemPoints(eqPoint)[num4];
                                var point3d10 = sysPoint.DimLinePoint;
                                var point3d11 = sysPoint.Dim1PointIndex != 1
                                    ? sysPoint.Dim1.XLine2Point
                                    : sysPoint.Dim1.XLine1Point;
                                if (Math.Abs(point3d10.DistanceTo(point3d11)) >= eqPoint)
                                {
                                    dimSys.Extend(num4, 0, point3d9, eqPoint);
                                    acTrans.TransactionManager.QueueForGraphicsFlush();
                                }
                                else
                                {
                                    acCurEd.WriteMessage("\nCannot extend lines with zero length.");
                                }
                            }
                        }

                        dimSys.Unhighlight();
                        acTrans.Commit();
                    }
                }
            }
        }
Esempio n. 24
0
            private void UpdateText()
            {
                Autodesk.AutoCAD.ApplicationServices.Document doc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;
                Autodesk.AutoCAD.DatabaseServices.Database    db  = doc.Database;

                Matrix3d ucs2wcs    = AcadUtility.AcadGraphics.UcsToWcs;
                Matrix3d wcs2ucs    = AcadUtility.AcadGraphics.WcsToUcs;
                Point3d  pBaseWorld = mpBase.TransformBy(ucs2wcs);
                Point3d  pTextWorld = mpText.TransformBy(ucs2wcs);

                MText    mtext = Entity as MText;
                Vector3d dir   = (mpText - mpBase);

                // Text attachment
                mtext.Location = pTextWorld;
                bool singleLine = (mtext.Attachment == AttachmentPoint.BottomLeft || mtext.Attachment == AttachmentPoint.BottomRight);

                // Text rotation and attachment
                if (mAutoRotateText)
                {
                    double lineRotation = mTextRotation * Math.PI / 180 + Vector3d.XAxis.GetAngleTo(dir, Vector3d.ZAxis);
                    double rot          = lineRotation * 180 / Math.PI;

                    if (rot > 90.0 && rot < 270.0)
                    {
                        lineRotation     = lineRotation + Math.PI;
                        mtext.Attachment = (singleLine ? AttachmentPoint.BottomRight : AttachmentPoint.MiddleRight);
                    }
                    else
                    {
                        mtext.Attachment = (singleLine ? AttachmentPoint.BottomLeft : AttachmentPoint.MiddleLeft);
                    }

                    mtext.Rotation = lineRotation;
                }
                else
                {
                    mtext.Rotation = mTextRotation * Math.PI / 180;
                }

                // Text to the right or left
                double textlineAngle = Vector3d.XAxis.RotateBy(mtext.Rotation, Vector3d.XAxis).GetAngleTo(dir) * 180 / Math.PI;

                if (textlineAngle > 90.0 && textlineAngle < 270.0)
                {
                    mtext.Attachment = (singleLine ? AttachmentPoint.BottomRight : AttachmentPoint.MiddleRight);
                }
                else
                {
                    mtext.Attachment = (singleLine ? AttachmentPoint.BottomLeft : AttachmentPoint.MiddleLeft);
                }

                // Create and update line
                IntegerCollection vpNumbers = AcadUtility.AcadGraphics.GetActiveViewportNumbers();

                if (line == null)
                {
                    line = new Line();
                    TransientManager.CurrentTransientManager.AddTransient(line, TransientDrawingMode.DirectShortTerm, 0, vpNumbers);
                }
                line.StartPoint = pBaseWorld;
                line.EndPoint   = pTextWorld;
                TransientManager.CurrentTransientManager.UpdateTransient(line, vpNumbers);
            }
Esempio n. 25
0
 public CustomTabOffsetsEnumerator(IntegerCollection items)
 {
     this.items = items;
     current    = -1;
 }
Esempio n. 26
0
        public void Cmd_DimAdd()
        {
            if (!LicensingAgent.Check())
            {
                return;
            }
            var acCurDoc = Application.DocumentManager.MdiActiveDocument;
            var acCurDb  = acCurDoc.Database;
            var acCurEd  = acCurDoc.Editor;

            var prEntOpt = new PromptEntityOptions("\nSelect a dimension system to add to: ");

            prEntOpt.SetRejectMessage("\nOnly linear dimensions may be selected.");
            prEntOpt.AllowNone = false;
            prEntOpt.AddAllowedClass(typeof(RotatedDimension), false);

            var prEntRes = acCurEd.GetEntity(prEntOpt);

            if (prEntRes.Status != PromptStatus.OK)
            {
                return;
            }

            var objId     = prEntRes.ObjectId;
            var addMatrix = acCurEd.GetAlignedMatrix();

            var eqPoint = CalcTol.ReturnCurrentTolerance();

            using (var acTrans = acCurDb.TransactionManager.StartTransaction())
            {
                var acEnt = acTrans.GetObject(objId, OpenMode.ForWrite) as Entity;
                if (acEnt != null)
                {
                    acEnt.Unhighlight();

                    var acRotDim = acEnt as RotatedDimension;
                    if (acRotDim != null)
                    {
                        var dimSys = DimSystem.GetSystem(acRotDim, eqPoint, eqPoint);

                        var prPtOpts =
                            new PromptPointOptions("\nSelect point to add: ");

                        while (true)
                        {
                            dimSys.Highlight();

                            var dPoints = dimSys.GetSystemPoints(eqPoint);

                            var dimLinPt = new Point3d();
                            var pt       = new Point3d();
                            var bl       = false;

                            foreach (var dPt in dPoints)
                            {
                                if (bl)
                                {
                                    pt = dPt.DimLinePoint;
                                    break;
                                }

                                dimLinPt = dPt.DimLinePoint;
                                bl       = true;
                            }

                            var nArray = DimSystem.GetActiveViewCount();

                            var currentTransientManager = TransientManager.CurrentTransientManager;

                            var acLine    = new Line(new Point3d(0, 0, 0), new Point3d(0, 0, 0));
                            var acPreview = new Line(new Point3d(0, 0, 0), new Point3d(0, 0, 0));

                            acLine.Color    = SettingsUser.DynPreviewColor;
                            acPreview.Color = SettingsUser.DynPreviewColor;

                            var integerCollections = new IntegerCollection(nArray);

                            currentTransientManager.AddTransient(acLine, TransientDrawingMode.Main, 128,
                                                                 integerCollections);
                            currentTransientManager.AddTransient(acPreview, TransientDrawingMode.Main, 128,
                                                                 integerCollections);

                            void PointMonitorEventHandler(object sender, PointMonitorEventArgs e)
                            {
                                var point3dArray = DimSystem.GetSystemPoint(dimLinPt, pt, e.Context.ComputedPoint);

                                acLine.StartPoint = point3dArray[0];
                                acLine.EndPoint   = point3dArray[1];

                                acPreview.StartPoint = point3dArray[1];
                                acPreview.EndPoint   = e.Context.ComputedPoint;

                                currentTransientManager.UpdateTransient(acLine, integerCollections);
                                currentTransientManager.UpdateTransient(acPreview, integerCollections);
                            }

                            acCurEd.PointMonitor += PointMonitorEventHandler;

                            PromptPointResult ptRes;
                            try
                            {
                                ptRes = acCurEd.GetPoint(prPtOpts);
                            }
                            finally
                            {
                                acCurEd.PointMonitor -= PointMonitorEventHandler;

                                currentTransientManager.EraseTransient(acLine, integerCollections);
                                currentTransientManager.EraseTransient(acPreview, integerCollections);

                                acLine.Dispose();
                                acPreview.Dispose();
                            }

                            if (ptRes.Status != PromptStatus.OK)
                            {
                                break;
                            }

                            dimSys.Insert(ptRes.Value.TransformBy(addMatrix));
                        }

                        dimSys.Unhighlight();
                    }
                }

                acTrans.Commit();
            }
        }
Esempio n. 27
0
        /// <summary>
        /// Replace the list of root album IDs for the <paramref name="role"/> with the album ID's specified in
        /// <paramref name="topLevelCheckedAlbumIds"/>. Note that this function will cause the AllAlbumIds property 
        /// to be cleared out (Count = 0). The property can be repopulated by calling <see cref="IGalleryServerRole.Save"/>.
        /// </summary>
        /// <param name="role">The role whose root album/role relationships should be updated. When editing
        /// an existing role, specify this.GalleryRole. For new roles, pass the newly created role before
        /// saving it.</param>
        /// <param name="topLevelCheckedAlbumIds">The top level album IDs. May be null.</param>
        /// <exception cref="ArgumentNullException">Thrown when <paramref name="role" /> is null.</exception>
        private static void UpdateRoleAlbumRelationships(IGalleryServerRole role, IIntegerCollection topLevelCheckedAlbumIds)
        {
            if (role == null)
                throw new ArgumentNullException("role");

            if (topLevelCheckedAlbumIds == null)
                topLevelCheckedAlbumIds = new IntegerCollection();

            int[] rootAlbumIdsOld = new int[role.RootAlbumIds.Count];
            role.RootAlbumIds.CopyTo(rootAlbumIdsOld, 0);

            role.RootAlbumIds.Clear();

            if (role.AllowAdministerSite)
            {
                // Administer site permission automatically applies to all albums, so all we need to do is get
                // a reference to the root album ID in each gallery.
                foreach (IGallery gallery in role.Galleries)
                {
                    role.RootAlbumIds.Add(Factory.LoadRootAlbumInstance(gallery.GalleryId).Id);
                }
            }
            else if (role.AllowAdministerGallery)
            {
                // Administer gallery permission automatically applies to all albums in a gallery, so get a reference
                // to the root album for each checked album ID.
                foreach (int albumId in topLevelCheckedAlbumIds)
                {
                    IAlbum album = AlbumController.LoadAlbumInstance(albumId, false);

                    while (!(album.Parent is GalleryServerPro.Business.NullObjects.NullGalleryObject))
                    {
                        album = (IAlbum)album.Parent;
                    }

                    if (!role.RootAlbumIds.Contains(album.Id))
                    {
                        role.RootAlbumIds.Add(album.Id);
                    }
                }
            }
            else
            {
                role.RootAlbumIds.AddRange(topLevelCheckedAlbumIds);
            }

            if (IsRoleAnAlbumOwnerRole(role.RoleName))
                ValidateAlbumOwnerRoles(role.RoleName, rootAlbumIdsOld, role.RootAlbumIds);
        }
Esempio n. 28
0
        public void Play()
        {
            //Doc = Application.DocumentManager.MdiActiveDocument;
            //Db = Doc.Database;
            //DL = Doc.LockDocument(DocumentLockMode.ProtectedAutoWrite, null, null, true);

            //Editor Editor = Application.DocumentManager.MdiActiveDocument.Editor;

            PromptSelectionResult acPSR = AC.Editor.GetSelection();

            // 선택한 객체를 받음
            if (acPSR.Status == PromptStatus.OK)
            {
                var edgePtrs  = new Curve2dCollection();
                var edgeTypes = new IntegerCollection();

                using (Transaction T = AC.DB.TransactionManager.StartTransaction())
                {
                    BlockTable       BT  = T.GetObject(AC.DB.BlockTableId, OpenMode.ForWrite) as BlockTable;
                    BlockTableRecord BTR = T.GetObject(BT[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;

                    SelectionSet acSSet = acPSR.Value;

                    foreach (var objID in acSSet.GetObjectIds())
                    {
                        var acEnt = T.GetObject(objID, OpenMode.ForWrite) as Entity;

                        if (acEnt is Polyline)
                        {
                            Polyline acPL = acEnt as Polyline;

                            GetEdgeInformation(acPL, ref edgePtrs, ref edgeTypes);
                        }
                    }
                }

                var acPolylines = from a in edgePtrs.Cast <Curve2d>()
                                  orderby a.StartPoint.GetDistanceTo(a.EndPoint) descending
                                  select a;

                //var usedCurve = new List<Curve2d>();
                var usedCurve = new List <Point2d>();

                acPolylines.Cast <Curve2d>().ToList().ForEach(c =>
                {
                    var CenterP = CADUtil.GetCenterPoint2d(c.StartPoint, c.EndPoint);

                    var curves = from a in edgePtrs.Cast <Curve2d>().ToList()
                                 where a != c
                                 select a;

                    // c와 평행한 선을 받음
                    var MatchedCurves                 = from a in curves
                                                let d = a.GetDistanceTo(c)
                                                        where CADUtil.GetVector(a).GetNormal().IsEqualTo(-CADUtil.GetVector(c).GetNormal())
                                                        where d > Min && d < Max
                                                        let cp1                     = CADUtil.GetCenterPoint2d(c)
                                                                            let cp2 = CADUtil.GetCenterPoint2d(a)
                                                                                      orderby cp1.GetDistanceTo(cp2) ascending
                                                                                      select a;

                    if (MatchedCurves.Any())
                    {
                        //CAD.CreateLine(c.StartPoint, c.EndPoint);

                        bool B = true;

                        MatchedCurves.ToList().ForEach(c1 =>
                        {
                            var cp1 = CADUtil.GetCenterPoint2d(c1);

                            usedCurve.ForEach(cp2 =>
                            {
                                if (cp1.IsEqualTo(cp2))
                                {
                                    B = false;
                                }
                            });
                        });

                        if (B)
                        {
                            CreateRectangle(c, MatchedCurves.ToList());

                            usedCurve.Add(CADUtil.GetCenterPoint2d(c));
                        }
                    }
                });
            }
            else
            {
                Application.ShowAlertDialog("Number of objects selected: 0");
            }
        }
Esempio n. 29
0
 public void GetObjectSnapPoints(ObjectSnapModes snapMode, int gsSelectionMark, Point3d pickPoint, Point3d lastPoint, Matrix3d viewTransform, Point3dCollection snapPoints, IntegerCollection geometryIds, Matrix3d insertionMat)
 {
     createInstance();
     BaseEntity.GetObjectSnapPoints(snapMode, gsSelectionMark, pickPoint, lastPoint, viewTransform, snapPoints, geometryIds, insertionMat);
     tr.Dispose();
 }
Esempio n. 30
0
        private void GetEdgeInformation(Polyline pline, ref Curve2dCollection plCurves, ref IntegerCollection edgeTypes)
        {
            int segCount = pline.NumberOfVertices;

            for (int cnt = 0; cnt < segCount; cnt++)
            {
                SegmentType type = pline.GetSegmentType(cnt);

                switch (type)
                {
                case SegmentType.Arc:

                    CircularArc2d arc2d = pline.GetArcSegment2dAt(cnt);

                    plCurves.Add(arc2d);

                    edgeTypes.Add((int)Enum.Parse(typeof(HatchEdgeType),

                                                  HatchEdgeType.CircularArc.ToString()));

                    break;

                case SegmentType.Line:

                    LineSegment2d line2d = pline.GetLineSegment2dAt(cnt);

                    plCurves.Add(line2d);

                    edgeTypes.Add((int)Enum.Parse(typeof(HatchEdgeType),

                                                  HatchEdgeType.Line.ToString()));

                    break;

                case SegmentType.Coincident:

                    break;

                case SegmentType.Empty:

                    break;

                case SegmentType.Point:

                    break;
                }
            }
        }
Esempio n. 31
0
		public ListBox ()
		{
			items = CreateItemCollection ();
			selected_indices = new SelectedIndexCollection (this);
			selected_items = new SelectedObjectCollection (this);

			requested_height = bounds.Height;
			InternalBorderStyle = BorderStyle.Fixed3D;
			BackColor = ThemeEngine.Current.ColorWindow;

			/* Vertical scrollbar */
			vscrollbar = new ImplicitVScrollBar ();
			vscrollbar.Minimum = 0;
			vscrollbar.SmallChange = 1;
			vscrollbar.LargeChange = 1;
			vscrollbar.Maximum = 0;
			vscrollbar.ValueChanged += new EventHandler (VerticalScrollEvent);
			vscrollbar.Visible = false;

			/* Horizontal scrollbar */
			hscrollbar = new ImplicitHScrollBar ();
			hscrollbar.Minimum = 0;
			hscrollbar.SmallChange = 1;
			hscrollbar.LargeChange = 1;
			hscrollbar.Maximum = 0;
			hscrollbar.Visible = false;
			hscrollbar.ValueChanged += new EventHandler (HorizontalScrollEvent);

			Controls.AddImplicit (vscrollbar);
			Controls.AddImplicit (hscrollbar);

			/* Events */
			MouseDown += new MouseEventHandler (OnMouseDownLB);
			MouseMove += new MouseEventHandler (OnMouseMoveLB);
			MouseUp += new MouseEventHandler (OnMouseUpLB);
			MouseWheel += new MouseEventHandler (OnMouseWheelLB);
			KeyUp += new KeyEventHandler (OnKeyUpLB);
			GotFocus += new EventHandler (OnGotFocus);
			LostFocus += new EventHandler (OnLostFocus);
			
			SetStyle (ControlStyles.UserPaint, false);

#if NET_2_0
			custom_tab_offsets = new IntegerCollection (this);
#endif
		}
Esempio n. 32
0
 public void GetGripPoints(Point3dCollection gripPoints, IntegerCollection snapModes, IntegerCollection geometryIds)
 {
     createInstance();
     BaseEntity.GetGripPoints(gripPoints, snapModes, geometryIds);
     tr.Dispose();
 }
Esempio n. 33
0
        /// <summary>
        /// Get a list of album IDs between the current instance and the specified <paramref name="topAlbumId" />. It works by
        /// analyzing the parent albums, recursively, of the current gallery object, until reaching either the root album or the specified
        /// <paramref name="topAlbumId" />. The caller is responsible for iterating through this list and calling 
        /// <see cref="Album.AssignAlbumThumbnail" /> for each album after the move operation is complete.
        /// This method should be called before the move operation takes place.
        /// </summary>
        /// <param name="topAlbumId">The ID of the album the current gallery object will be in after the move operation completes.</param>
        /// <returns>Return a list of album IDs whose thumbnail images will need updating after the move operation completes.</returns>
        protected IIntegerCollection GetAlbumHierarchy(int topAlbumId)
        {
            IIntegerCollection albumsInHierarchy = new IntegerCollection();
            IGalleryObject album = this.Parent;

            while (!(album is NullObjects.NullGalleryObject))
            {
                // If we're at the same level as the destination album, don't go any further.
                if (album.Id == topAlbumId)
                    break;

                albumsInHierarchy.Add(album.Id);

                album = album.Parent;
            }

            return albumsInHierarchy;
        }
Esempio n. 34
0
 public void GetObjectSnapPoints(ObjectSnapModes snapMode, int gsSelectionMark, Point3d pickPoint, Point3d lastPoint, Matrix3d viewTransform, Point3dCollection snapPoints, IntegerCollection geometryIds, Matrix3d insertionMat)
 {
     createInstance();
     BaseEntity.GetObjectSnapPoints(snapMode, gsSelectionMark, pickPoint, lastPoint, viewTransform, snapPoints, geometryIds, insertionMat);
     tr.Dispose();
 }
Esempio n. 35
0
 /// <devdoc>
 ///     Creates a new enumerator that will enumerate over the given state.
 /// </devdoc>
 public CustomTabOffsetsEnumerator(IntegerCollection items) {
     this.items = items;
     this.current = -1;
 }
Esempio n. 36
0
 public void MoveStretchPointsAt(IntegerCollection indices, Vector3d offset)
 {
     createInstance();
     BaseEntity.MoveStretchPointsAt(indices, offset);
     tr.Dispose();
 }
Esempio n. 37
0
        private ObjectId ProcessEntity(Polyline curve, BlockTable bt)
        {
            Database db           = bt.Database;
            ObjectId createdBtrId = ObjectId.Null;

            using (Transaction tr = db.TransactionManager.StartTransaction())
            {
                //Масштаб типа линии
                double ltScale = curve.LinetypeScale;
                //Глобальная ширина линии

                double offsetDist = 0;
                offsetDist = (curve as Polyline).GetStartWidthAt(0) / 2;

                if (offsetDist == 0)
                {
                    throw new System.Exception("Не определена глобальная ширина кривой");
                }


                //Анализ типа линии. Получить длину штриха и длину пробела
                LinetypeTableRecord ltype = tr.GetObject(curve.LinetypeId, OpenMode.ForRead) as LinetypeTableRecord;
                //Создать слой, который будет называться как тип линии
                string           layerName   = curve.Linetype;
                LayerTableRecord layerSample = tr.GetObject(curve.LayerId, OpenMode.ForRead) as LayerTableRecord;
                ObjectId         layerId     = Utils.CreateLayerIfNotExists(layerName, db, tr, layerSample);

                //string ltypeDef = ltype.Comments;
                //double patternLength = ltype.PatternLength;
                //int numDashes = ltype.NumDashes;
                if (ltype.Name.Equals("ByLayer"))
                {
                    ltype = tr.GetObject(layerSample.LinetypeObjectId, OpenMode.ForRead) as LinetypeTableRecord;
                }
                List <double> pattern = Utils.GetLinePattern(ltype, ltScale);

                bool startFromDash = false;//паттерн начинается со штриха (не пробела)
                if (pattern.Count > 0)
                {
                    startFromDash = pattern[0] > 0;
                }


                DoubleCollection splittingParams = new DoubleCollection();
                if (pattern.Count > 1)
                {
                    //Расчитать параметры для разбивки полилинии
                    double currParam = curve.StartParam;
                    double currDist  = curve.GetDistanceAtParameter(currParam);
                    double length    = curve.GetDistanceAtParameter(curve.EndParam);
                    int    dashNum   = 0;
                    while (true)
                    {
                        currDist += Math.Abs(pattern[dashNum]);
                        if (currDist < length)
                        {
                            currParam = curve.GetParameterAtDistance(currDist); //Параметр в конце текущего штриха
                            int nextDashNum = (dashNum + 1) % pattern.Count;    //следующий штрих согласно паттерну

                            if (Math.Sign(pattern[dashNum]) != Math.Sign(pattern[nextDashNum]))
                            {
                                //Если знаки текущего штриха и следующего разные
                                //(то есть граница между штрихом и пробелом),
                                //то добавить текущий параметр в разделители
                                splittingParams.Add(currParam);
                            }
                            dashNum = nextDashNum;//переход к следующему штриху
                        }
                        else
                        {
                            break;
                        }
                    }
                }


                List <Curve> curves = new List <Curve>();
                if (splittingParams.Count != 0)
                {
                    //Использовать метод Curve.GetSplitCurves для создания сегментов
                    DBObjectCollection splitted = curve.GetSplitCurves(splittingParams);
                    foreach (DBObject dbo in splitted)
                    {
                        if (dbo is Curve)
                        {
                            curves.Add(dbo as Curve);
                        }
                    }
                }
                else//Сплошная линия
                {
                    object o = curve.Clone();
                    if (o != null && o is Curve)
                    {
                        curves.Add(o as Curve);
                    }
                }

                if (curves.Count > 0)
                {
                    //Создать новый блок для сохранения замкнутых контуров

                    BlockTableRecord btr = new BlockTableRecord();
                    btr.Name = Guid.NewGuid().ToString();
                    n++;
                    createdBtrId = bt.Add(btr);
                    tr.AddNewlyCreatedDBObject(btr, true);

                    if (createdBtrId != ObjectId.Null)
                    {
                        bool currIsDash = startFromDash;
                        foreach (Curve axisCurve in curves)
                        {
                            if (currIsDash)
                            {
                                //Использовать метод Curve.GetOffsetCurves
                                //для создания линий границ справа и слева в соответствии с глобальной шириной
                                //Создание замкнутого контура в новом блоке
                                DBObjectCollection offsetCurves = axisCurve.GetOffsetCurves(offsetDist);
                                Curve c1 = Utils.GetFirstDBObject(offsetCurves) as Curve;
                                offsetCurves = axisCurve.GetOffsetCurves(-offsetDist);
                                Curve c2 = Utils.GetFirstDBObject(offsetCurves) as Curve;
                                if (!curve.Closed)//Если кривая не замкнута, то попытаться построить замкнутый контур из правой и левой кривой отступа
                                {
                                    try
                                    {
                                        Line concatLine = new Line(c1.EndPoint, c2.EndPoint /*.StartPoint*/);


                                        IntegerCollection joined
                                            = c1.JoinEntities(new Entity[] { concatLine, c2 });
                                        if (joined.Count < 2)
                                        {
                                            throw new System.Exception("Соединение примитивов не выполнено");
                                        }

                                        if (c1 is Polyline)
                                        {
                                            PrepareCurve(c1, layerId);
                                        }
                                        else
                                        {
                                            throw new System.Exception("При соединении примитивов создан невалидный объект");
                                        }

                                        btr.AppendEntity(c1);
                                        tr.AddNewlyCreatedDBObject(c1, true);
                                    }
                                    catch (System.Exception ex)
                                    {
                                        ed.WriteMessage("\nВНИМАНИЕ: Возникла ошибка при попытке создания контура в блоке " + btr.Name);
                                    }
                                }
                                else//Если кривая замкнута, то просто создать левую и правую кривую
                                {
                                    PrepareCurve(c1, layerId);
                                    PrepareCurve(c2, layerId);
                                    btr.AppendEntity(c1);
                                    tr.AddNewlyCreatedDBObject(c1, true);
                                    btr.AppendEntity(c2);
                                    tr.AddNewlyCreatedDBObject(c2, true);
                                }
                            }
                            currIsDash = !currIsDash;//Считаем, что штрихи и пробелы встречаются строго поочереди
                        }
                    }
                }

                tr.Commit();
            }


            return(createdBtrId);
        }
Esempio n. 38
0
        void updateInvisibleGrips()
        {
            ExGripDataCollection aOverall = new ExGripDataCollection();

            foreach (KeyValuePair <ObjectId, ExGripDataExt> grDataDc in m_gripDataDict)
            {
                foreach (ExGripData grData in grDataDc.Value.DataArray)
                {
                    aOverall.Add(grData);
                }
                foreach (ExGripDataSubent grDataSub in grDataDc.Value.DataSub)
                {
                    foreach (ExGripData grData in grDataSub.SubData)
                    {
                        aOverall.Add(grData);
                    }
                }
            }

            int iSize = aOverall.Count;

            for (int i = 0; i < iSize; i++)
            {
                ExGripData grData = aOverall[i];
                grData.Invisible = false;
                grData.Shared    = false;

                IntegerCollection aEq = new IntegerCollection();
                aEq.Add(i);

                Point3d ptIni = grData.Point;

                int       iNext = i + 1;
                Tolerance tc    = new Tolerance(1E-6, 1E-6);
                while (iNext < iSize)
                {
                    Point3d ptCur = aOverall[iNext].Point;
                    if (ptIni.IsEqualTo(ptCur, tc))
                    {
                        aEq.Add(iNext);
                        iNext++;
                    }
                    else
                    {
                        break;
                    }
                }

                if (aEq.Count >= 2)
                {
                    int iVisible = 0;
                    int jSize    = aEq.Count;
                    for (int j = 0; j < iSize; j++)
                    {
                        ExGripData pGrip = aOverall[aEq[j]];

                        bool bOk = true;
                        if (pGrip.Data != null)
                        {
                            if (pGrip.Data.SkipWhenShared)
                            {
                                bOk = false;
                            }
                        }

                        if (bOk)
                        {
                            iVisible = j;
                            break;
                        }
                    }

                    for (int j = 0; j < iSize; j++)
                    {
                        ExGripData pGrip = aOverall[aEq[j]];
                        pGrip.Shared    = true;
                        pGrip.Invisible = (j != iVisible);
                    }
                }
            }
        }
Esempio n. 39
0
		/// <summary>
		/// Replace the list of root album IDs for the <paramref name="role"/> with the album ID's specified in
		/// <paramref name="topLevelCheckedAlbumIds"/>. Note that this function will cause the AllAlbumIds property 
		/// to be cleared out (Count = 0). The property can be repopulated by calling <see cref="IGalleryServerRole.Save"/>.
		/// </summary>
		/// <param name="role">The role whose root album/role relationships should be updated. When editing
		/// an existing role, specify this.GalleryRole. For new roles, pass the newly created role before
		/// saving it.</param>
		/// <param name="topLevelCheckedAlbumIds">The top level checked album ids. May be null.</param>
		public static void UpdateRoleAlbumRelationships(IGalleryServerRole role, IIntegerCollection topLevelCheckedAlbumIds)
		{
			if (role == null)
				throw new ArgumentNullException("role");

			if (topLevelCheckedAlbumIds == null)
				topLevelCheckedAlbumIds = new IntegerCollection();

			int[] rootAlbumIdsOld = new int[role.RootAlbumIds.Count];
			role.RootAlbumIds.CopyTo(rootAlbumIdsOld, 0);

			role.RootAlbumIds.Clear();

			if (role.AllowAdministerSite)
			{
				// Administer site permission automatically applies to all albums, so all we need to do is get
				// a reference to the root album ID.
				role.RootAlbumIds.Add(Factory.LoadRootAlbumInstance().Id);
			}
			else
			{
				role.RootAlbumIds.AddRange(topLevelCheckedAlbumIds);
			}

			if (IsRoleAnAlbumOwnerRole(role.RoleName))
				ValidateAlbumOwnerRoles(role.RoleName, rootAlbumIdsOld, role.RootAlbumIds);
		}
Esempio n. 40
0
        private ObjectId TrimPickUP(int nodeNumer, int TriangleNumer, double X, double angle)
        {
            //UtilityClasses.ConstantsAndSettings.DoubleGlass_h1
            //UtilityClasses.ConstantsAndSettings.DoubleGlass_h2
            //UtilityClasses.ConstantsAndSettings.Thickness_of_the_Glass
            #region basedata
            Database db = HostApplicationServices.WorkingDatabase;
            Editor   ed = Application.DocumentManager.MdiActiveDocument.Editor;

            ed.WriteMessage("\n");
            ed.WriteMessage(angle.ToString());

            var        node     = container.Nodes[nodeNumer];
            Triangle   TR       = container.Triangles[TriangleNumer];
            quaternion trNormal = TR.Normal.Second - TR.Normal.First;
            trNormal /= trNormal.abs();
            plane trPlane = new plane(TR.Nodes.First, TR.Nodes.Second, TR.Nodes.Third);


            Point3dCollection pColl = new Point3dCollection();
            IntegerCollection iCol1 = new IntegerCollection();
            IntegerCollection iCol2 = new IntegerCollection();



            using (Transaction tr = db.TransactionManager.StartTransaction())
            {
                if ((TR.upSolidHandle.First >= 0) && (TR.upSolidHandle.Second != null))
                {
                    try
                    {
                        Solid3d upSolid = tr.GetObject(GlobalFunctions.GetObjectId(TR.upSolidHandle.Second), OpenMode.ForWrite) as Solid3d;
                        upSolid.GetGripPoints(pColl, iCol1, iCol2);
                    }
                    catch { }
                }
            }


            Bend bend1 = container.Bends[TR.GetFirstBendNumer()];
            Bend bend2 = container.Bends[TR.GetSecondBendNumer()];
            Bend bend3 = container.Bends[TR.GetThirdBendNumer()];
            #endregion

            List <Bend> bends = new List <Bend>();
            if ((bend1.StartNodeNumer == nodeNumer) || (bend1.EndNodeNumer == nodeNumer))
            {
                bends.Add(bend1);
            }
            if ((bend2.StartNodeNumer == nodeNumer) || (bend2.EndNodeNumer == nodeNumer))
            {
                bends.Add(bend2);
            }
            if ((bend3.StartNodeNumer == nodeNumer) || (bend3.EndNodeNumer == nodeNumer))
            {
                bends.Add(bend3);
            }

            if (bends.Count != 2)
            {
                MessageBox.Show("Only two Bends are connected at one point !", "E R R O R");
                return(ObjectId.Null);
            }

            if (bends[0].IsFictive() || bends[1].IsFictive())
            {
                return(ObjectId.Null);
            }

            quaternion Q0 = node.Position;
            quaternion Q1 = (bends[0].Start + bends[0].End) / 2.0;
            quaternion Q2 = (bends[1].Start + bends[1].End) / 2.0;

            // coorinat systems for plane points calculate
            Q1 = Q1 - Q0; Q1 /= Q1.abs(); Q1 *= X; Q1 = Q0 + Q1;
            Q2 = Q2 - Q0; Q2 /= Q2.abs(); Q2 *= X; Q2 = Q0 + Q2;

            UCS ucs = new UCS(Q0, (Q1 + Q2) / 2.0, Q2);
            ucs = new UCS(Q0, ucs.ToACS(new quaternion(0, 0, 100, 0)), ucs.ToACS(new quaternion(0, 100, 0, 0)));

            #region UP glass

            double     dist = (node.Position - (quaternion)pColl[0]).abs();
            quaternion pick = new quaternion();

            foreach (Point3d p in pColl)
            {
                quaternion q = (quaternion)p;
                double     z = (node.Position - q).abs();

                if (z < dist)
                {
                    dist = z;
                    pick = new quaternion(0, p.X, p.Y, p.Z);
                }
            }
            pColl.Clear(); pColl.Dispose();
            iCol1.Clear();
            iCol1.Clear();
            #endregion


            ucs.o = pick;
            Q1    = pick + Q1 - Q0;
            Q2    = pick + Q2 - Q0;
            Q0    = pick;

            // UtilityClasses.GlobalFunctions.DrawLine((Point3d)Q0, new Point3d(), 1);

            quaternion t1 = (Q2 - Q1) * 2.0;
            quaternion t2 = (Q1 - Q2) * 2.0;
            Q1 = Q1 + t2;
            Q2 = Q2 + t1;

            Matrix3d mat = new Matrix3d(ucs.GetAutoCAD_Matrix3d());
            Q1 = ucs.FromACS(Q1);
            Q2 = ucs.FromACS(Q2);
            quaternion   Q3  = new quaternion(0, Q1.GetX(), -Q1.GetY(), Q1.GetZ());
            quaternion   Q4  = new quaternion(0, Q2.GetX(), -Q2.GetY(), Q2.GetZ());
            quaternion[] arr = { Q1, Q2, Q4, Q3, Q1 };
            ObjectId     obj = ObjectId.Null;
            using (Transaction tr = db.TransactionManager.StartTransaction())
            {
                BlockTable       acBlkTbl    = tr.GetObject(db.BlockTableId, OpenMode.ForRead) as BlockTable;
                BlockTableRecord acBlkTblRec = tr.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;

                Polyline pol = GlobalFunctions.GetPoly(ref arr);
                //pol.TransformBy(Matrix3d.Displacement(new Point3d().GetVectorTo(new Point3d(0, 0, -100))));
                //pol.TransformBy(mat);

                //acBlkTblRec.AppendEntity(pol);
                //tr.AddNewlyCreatedDBObject(pol, true);

                try
                {
                    Solid3d sol = new Solid3d();
                    sol.CreateExtrudedSolid(pol, new Point3d(0, 0, 0).GetVectorTo(new Point3d(0, 0, 100)), new SweepOptions());
                    sol.TransformBy(Matrix3d.Displacement(new Point3d().GetVectorTo(new Point3d(0, 0, -50))));
                    sol.TransformBy(mat);
                    acBlkTblRec.AppendEntity(sol);
                    tr.AddNewlyCreatedDBObject(sol, true);
                    obj = sol.ObjectId;
                }
                catch { }

                tr.Commit();
            }

            /*
             * if (obj != ObjectId.Null)
             * {
             *  using (Transaction tr = db.TransactionManager.StartTransaction())
             *  {
             *
             *      Solid3d sol = tr.GetObject(obj, OpenMode.ForWrite) as Solid3d;
             *      Solid3d ent = tr.GetObject(UtilityClasses.GlobalFunctions.GetObjectId(TR.lowSolidHandle.Second), OpenMode.ForWrite) as Solid3d;
             *      ent.BooleanOperation(BooleanOperationType.BoolSubtract, sol);
             *
             *      tr.Commit();
             *  }
             * }*/



            // ed.WriteMessage("\n");
            // ed.WriteMessage(ucs.FromACS(Q0).ToString());
            // ed.WriteMessage("\n-----------------------------\n");

            return(obj);
        }