enum DimensionDirection
        {
            Horizental, Vertical, Rotated
        }

        class RotatedDimensionJig : EntityJig
        {
            Point3d mStartPt, mEndPt, mLocPt;
            Point3d mNewEndPt;
            double mRotation;

            int mPromptCounter;

            DimensionDirection mDimensionDirection;
            public RotatedDimensionJig(Point3d startPt, Point3d endPt)
                : base(new RotatedDimension())
            {
                mStartPt = startPt;
                mEndPt = endPt;
                mPromptCounter = 0;
                mDimensionDirection = DimensionDirection.Horizental;
            }

 
            protected override SamplerStatus Sampler(JigPrompts prompts)
            {
                JigPromptOptions jigOpts = new JigPromptOptions();
                jigOpts.UserInputControls = (UserInputControls.Accept3dCoordinates | UserInputControls.NoZeroResponseAccepted | UserInputControls.NoNegativeResponseAccepted | UserInputControls.NullResponseAccepted);
                if (mPromptCounter == 0)
                {
                    jigOpts.Message = "\ninput dimension loction";
                    PromptPointResult dres = prompts.AcquirePoint(jigOpts);

                    Point3d locPointTemp = dres.Value;
                    if (locPointTemp != mLocPt)
                    {
                        mLocPt = locPointTemp;
                    }
                    else
                        return SamplerStatus.NoChange;

                    if (dres.Status == PromptStatus.Cancel)
                        return SamplerStatus.Cancel;
                    else
                        return SamplerStatus.OK;
                }
                else if (mPromptCounter == 1)
                {
                    jigOpts.Message = "\ninput next point";
                    PromptPointResult dres = prompts.AcquirePoint(jigOpts);

                    Point3d endPointTemp = dres.Value;
                    if (endPointTemp != mEndPt)
                    {
                        mEndPt = endPointTemp;
                    }
                    else
                        return SamplerStatus.NoChange;

                    if (dres.Status == PromptStatus.Cancel)
                        return SamplerStatus.Cancel;
                    else
                        return SamplerStatus.OK;

                }
                else
                {
                    return SamplerStatus.NoChange;
                }
            }

            protected override bool Update()
            {
                try
                {
                    switch (mPromptCounter)
                    {
                        case 0:
                            GetRotationAndDimensionDirection();
                            break;
                        case 1:
                            break;
                    }
                    GetNewEndPoint();
                    RotatedDimension dimEnt = ((RotatedDimension)Entity);
                    //dimEnt = new RotatedDimension(mRotation, mStartPt, mNewEndPt, mLocPt, "", ObjectId.Null);
                    dimEnt.XLine1Point = mStartPt;
                    dimEnt.XLine2Point = mNewEndPt;
                    dimEnt.DimLinePoint = mLocPt;
                    dimEnt.Rotation = mRotation; // this line will throw a exception
                }
                catch (System.Exception)
                {
                    return false;
                }
                return true;

            }
            void GetRotationAndDimensionDirection()
            {
                double deltaX = mEndPt.X - mStartPt.X;
                double deltaY = mEndPt.Y - mStartPt.Y;
                
                if (
                    System.Math.Abs(deltaY) < 1e-3 ||
                    (Math.Abs(mLocPt.X - mStartPt.X) < Math.Abs(mEndPt.X - mStartPt.X)) &&
                    (Math.Abs(mLocPt.X - mEndPt.X) < Math.Abs(mEndPt.X - mStartPt.X))) //horizental
                {
                    mRotation = 0;
                    mDimensionDirection = DimensionDirection.Horizental;
                }
                else if (
                    System.Math.Abs(deltaX) < 1e-3 ||
                    (Math.Abs(mLocPt.Y - mStartPt.Y) < Math.Abs(mEndPt.Y - mStartPt.Y)) &&
                    (Math.Abs(mLocPt.Y - mEndPt.Y) < Math.Abs(mEndPt.Y - mStartPt.Y))) //vertical
                {
                    mDimensionDirection = DimensionDirection.Vertical;
                    mRotation = System.Math.PI / 2;
                }
                else // rotated 
                {
                    mDimensionDirection = DimensionDirection.Rotated;
                    double k = deltaY / deltaX;
                    mRotation = System.Math.Atan(k);
                }
            }

            void GetNewEndPoint()
            {
                switch (mDimensionDirection)
                {
                    case DimensionDirection.Horizental:
                        mNewEndPt = new Point3d(mEndPt.X, mStartPt.Y, 0);
                        break;
                    case DimensionDirection.Vertical:
                        mNewEndPt = new Point3d(mStartPt.X, mEndPt.Y, 0);
                        break;
                    case DimensionDirection.Rotated:
                        double deltaX = mEndPt.X - mStartPt.X;
                        double deltaY = mEndPt.Y - mStartPt.Y;
                        double k = deltaY / deltaX;
                        double temp1 = mEndPt.Y - mStartPt.Y + mEndPt.X / k + mStartPt.X * k;
                        double temp2 = 1 / k + k;
                        double x = temp1 / temp2;
                        double y = mEndPt.X * k + mStartPt.Y - k * mStartPt.X;
                        mNewEndPt = new Point3d(x, y, 0);
                        break;
                    default:
                        break;
                }

            }

            public void setPromptCounter(int i)
            {
                mPromptCounter = i;
                if (i == 1)
                {
                    mStartPt = mNewEndPt;
                }
            }



            public RotatedDimension GetEntity()
            {
                return new RotatedDimension(mRotation, mStartPt, mNewEndPt, mLocPt, "", ObjectId.Null);

            }

            public DimensionDirection GetDimensionDirection()
            {
                return mDimensionDirection;
            }
        }


        [CommandMethod("Cai_DimLinear")]
        public static void DoIt()
        {

            #region Get start point and end point 

            string prompt;
            PromptPointOptions po;
            PromptPointResult res;

            prompt = "\ninput start point:";
            po = new PromptPointOptions(prompt);
            po.AllowNone = true;
            res = Arx.Editor.GetPoint(po);
            if (res.Status != PromptStatus.OK) return;
            Point3d startPoint = res.Value;

            prompt = "\ninput end point:";
            po.UseBasePoint = true;
            po.UseDashedLine = true;
            po.BasePoint = startPoint;
            po.Message = prompt;
            res = Arx.Editor.GetPoint(po);
            if (res.Status != PromptStatus.OK) return;
            Point3d endPoint = res.Value; 
            #endregion

            LayerTableRecord ltr = new LayerTableRecord();
            ltr.Name = "S_Dims";
            ltr.Color = Color.FromColorIndex(ColorMethod.ByAci, 224);
            ObjectId layerId = Arx.AddLayer(ltr);
            ObjectId dimId = CreateDimStyle(0);
            Arx.CurDatabase.Clayer = layerId;

            //Create Dimensionjig
            RotatedDimensionJig jig = new RotatedDimensionJig(startPoint, endPoint);
            ArrayList list = new ArrayList();

            //first call drag to get the major axis
            jig.setPromptCounter(0);
            if (Arx.Editor.Drag(jig).Status != PromptStatus.OK) return;

            RotatedDimension firstDim = jig.GetEntity();
            list.Add(Arx.AddEntity(firstDim));

            bool exit = false;
            do
            {
                jig.setPromptCounter(1);
                PromptResult nRes = Arx.Editor.Drag(jig);
                if (nRes.Status != PromptStatus.OK)
                {
                    exit = true;
                }
                else
                {
                    RotatedDimension nextDim = jig.GetEntity();
                    if (Math.Abs(nextDim.Measurement) > 1e-3)
                    {
                        list.Add(Arx.AddEntity(nextDim));
                    }
                }

            } while (!exit);

            ReSortDimTextPosition(list, jig.GetDimensionDirection());
            AdjustDimTextPosition(list);

        }