예제 #1
0
        void locateGripsAtInt(int x, int y, ref ExGripDataCollection aRes, ExGripDataCollection coll, Point3d ptFirst, Tolerance tol)
        {
            foreach (ExGripData exgrData in coll)
            {
                Point3d ptCurrent = exgrData.Point;
                if (aRes.Count == 0)
                {
                    // First grip is obtained by comparing
                    // grip point device position with cursor position.
                    using (Teigha.GraphicsSystem.View pView = m_pDevice.ActiveView)
                    {
                        Point3d ptDC = ptCurrent.TransformBy(pView.WorldToDeviceMatrix);

                        double dDeltaX = Math.Abs(x - ptDC.X);
                        double dDeltaY = Math.Abs(y - ptDC.Y);
                        bool   bOk     = (dDeltaX <= m_GRIPSIZE) && (dDeltaY <= m_GRIPSIZE);
                        if (bOk)
                        {
                            ptFirst = ptCurrent;
                            aRes.Add(exgrData);
                        }
                    }
                }
                else
                {
                    if (ptCurrent.IsEqualTo(ptFirst, tol))
                    {
                        aRes.Add(exgrData);
                    }
                }
            }
        }
예제 #2
0
        bool locateActiveGrips(out IntegerCollection aIndices)
        {
            ExGripDataCollection grDataCol = entPath() ? m_pOwner.GetSubentGripData(m_pOwner.GripDataDict[entityId()], subentPath).SubData :
                                             m_pOwner.GripDataDict[entityId()].DataArray;

            bool bExMethod = true;

            aIndices = new IntegerCollection();
            int i = 0;

            foreach (ExGripData dat in grDataCol)
            {
                if (null == dat.Data)
                {
                    bExMethod = false;
                }

                if (GripData.DrawType.DragImageGrip == dat.Status)
                {
                    aIndices.Add(i);
                }
                i++;
            }
            return(bExMethod);
        }
예제 #3
0
        public bool startHover(int x, int y)
        {
            bool bRet = endHover();
            ExGripDataCollection aKeys = new ExGripDataCollection();

            locateGripsAt(x, y, ref aKeys);

            if (0 != aKeys.Count)
            {
                m_hoverGripsColl = aKeys;
                foreach (ExGripData gr in m_hoverGripsColl)
                {
                    if (GripData.DrawType.WarmGrip == gr.Status)
                    {
                        gr.Status = GripData.DrawType.HoverGrip;

                        if (m_pGsModel != null)
                        {
                            m_pGsModel.OnModified(gr, null);
                        }
                        else
                        {
                            m_pDevice.Invalidate();
                        }
                    }
                }
                bRet = true;
            }
            return(bRet);
        }
예제 #4
0
 public void uninit()
 {
     m_pDevice        = null;
     m_pGsModel       = null;
     m_hoverGripsColl = null;
     m_gripDataDict   = null;
     m_aDrags         = null;
 }
예제 #5
0
 public ExGripManager()
 {
     m_hoverGripsColl = new ExGripDataCollection();
     m_ptBasePoint    = Point3d.Origin;
     m_ptLastPoint    = Point3d.Origin;
     m_gripDataDict   = new Dictionary <ObjectId, ExGripDataExt>();
     m_aDrags         = new ExGripDragCollection();
 }
예제 #6
0
        public void locateGripsAt(int x, int y, ref ExGripDataCollection aRes)
        {
            Point3d   ptFirst = new Point3d();
            Tolerance tol     = new Tolerance(1E-4, 1E-4);

            foreach (KeyValuePair <ObjectId, ExGripDataExt> grData in m_gripDataDict)
            {
                locateGripsAtInt(x, y, ref aRes, grData.Value.DataArray, ptFirst, tol);
                foreach (ExGripDataSubent exgrData in grData.Value.DataSub)
                {
                    locateGripsAtInt(x, y, ref aRes, exgrData.SubData, ptFirst, tol);
                }
            }
        }
예제 #7
0
        public void moveEntity(Point3d ptMoveAt)
        {
            IntegerCollection aIndices;
            bool     bExMethod = locateActiveGrips(out aIndices);
            Vector3d vOffset   = ptMoveAt - m_pOwner.BasePoint;

            using (DBObject dbObj = entityId().GetObject(OpenMode.ForWrite))
            {
                if (dbObj is Entity)
                {
                    Entity ent = (Entity)dbObj;
                    ExGripDataCollection grDataCol = entPath() ? m_pOwner.GetSubentGripData(m_pOwner.GripDataDict[entityId()], subentPath).SubData :
                                                     m_pOwner.GripDataDict[entityId()].DataArray;

                    if (bExMethod)
                    {
                        IntPtr[] aIds  = new IntPtr[aIndices.Count];
                        int      index = 0;
                        foreach (int i in aIndices)
                        {
                            if (i < grDataCol.Count)
                            {
                                aIds[index++] = grDataCol[i].Data.AppData;
                            }
                        }

                        if (entPath())
                        {
                            FullSubentityPath[] aPaths = new FullSubentityPath[1];
                            aPaths[0] = subentPath;
                            ent.MoveGripPointsAtSubentityPaths(aPaths, aIds, vOffset, 0);
                        }
                        else
                        {
                            ent.MoveGripPointsAt(aIds, vOffset, MoveGripPointsFlags.Osnapped);
                        }
                    }
                    else
                    {
                        ent.MoveGripPointsAt(aIndices, vOffset);
                    }
                }
            }
        }
예제 #8
0
        public void DragFinal(Point3d ptFinal, bool bOk)
        {
            if (bOk)
            {
                using (Teigha.GraphicsSystem.View pView = m_pDevice.ActiveView)
                {
                    foreach (ExGripDrag grDrag in m_aDrags)
                    {
                        grDrag.moveEntity(ptFinal);

                        pView.Erase(grDrag);
                        grDrag.notifyDragEnded();
                        updateEntityGrips(grDrag.entityId());
                        grDrag.uninit();
                    }
                }
            }
            else
            {
                foreach (ExGripDrag grDrag in m_aDrags)
                {
                    grDrag.notifyDragAborted();
                }
            }

            m_aDrags.Clear();

            if (bOk)
            {
                updateInvisibleGrips();
            }

            foreach (ExGripData exgrData in aActiveKeys)
            {
                exgrData.Status = GripData.DrawType.WarmGrip;
            }
            aActiveKeys = null;
        }
예제 #9
0
        void locateGripsByStatus(GripData.DrawType eStatus, ref ExGripDataCollection aResult)
        {
            foreach (KeyValuePair <ObjectId, ExGripDataExt> grData in m_gripDataDict)
            {
                foreach (ExGripData exgrDat in grData.Value.DataArray)
                {
                    if (exgrDat.Status == eStatus)
                    {
                        aResult.Add(exgrDat);
                    }
                }

                foreach (ExGripDataSubent exgrData in grData.Value.DataSub)
                {
                    foreach (ExGripData exgrDat in exgrData.SubData)
                    {
                        if (exgrDat.Status == eStatus)
                        {
                            aResult.Add(exgrDat);
                        }
                    }
                }
            }
        }
예제 #10
0
 public ExGripDataExt()
 {
     m_pDataArray = new ExGripDataCollection();
     m_pDataSub   = new ExGripDataSubentCollection();
 }
예제 #11
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);
                    }
                }
            }
        }
예제 #12
0
        public bool OnMouseDown(int x, int y)
        {
            endHover();

            ExGripDataCollection aKeys = new ExGripDataCollection();

            locateGripsAt(x, y, ref aKeys);
            if (aKeys.Count > 0)
            {
                //if ( bShift )  TODO
                {
                    bool bMakeHot = true;

                    foreach (KeyValuePair <ObjectId, ExGripDataExt> grData in m_gripDataDict)
                    {
                        foreach (ExGripData exgrData in grData.Value.DataArray)
                        {
                            if (GripData.DrawType.HotGrip == exgrData.Status)
                            {
                                bMakeHot = false;
                                break;
                            }
                        }

                        foreach (ExGripDataSubent grDatSub in grData.Value.DataSub)
                        {
                            foreach (ExGripData exgrData in grDatSub.SubData)
                            {
                                if (GripData.DrawType.HotGrip == exgrData.Status)
                                {
                                    bMakeHot = false;
                                    break;
                                }
                            }
                            if (bMakeHot == false)
                            {
                                break;
                            }
                        }

                        if (bMakeHot == false)
                        {
                            break;
                        }
                    }

                    if (bMakeHot)
                    {
                        foreach (ExGripData exgrData in aKeys)
                        {
                            exgrData.Status = GripData.DrawType.HotGrip;
                        }
                    }

                    aActiveKeys = new ExGripDataCollection();
                    locateGripsByStatus(GripData.DrawType.HotGrip, ref aActiveKeys);
                    if (aActiveKeys.Count == 0)
                    {
                        // Valid situation.
                        // If trigger grip performed entity modification and returned eGripHotToWarm
                        // then nothing is to be done cause entity modification will cause reactor to regen grips.
                        return(false);
                    }

                    foreach (ExGripData exgrData in aActiveKeys)
                    {
                        exgrData.Status = GripData.DrawType.DragImageGrip;
                    }

                    foreach (KeyValuePair <ObjectId, ExGripDataExt> grData in m_gripDataDict)
                    {
                        bool bActive = false;
                        foreach (ExGripData exgrData in grData.Value.DataArray)
                        {
                            if (GripData.DrawType.DragImageGrip == exgrData.Status)
                            {
                                bActive = true;
                                m_aDrags.Add(new ExGripDrag(grData.Key, this));
                                break;
                            }
                        }
                        foreach (ExGripDataSubent grDatSub in grData.Value.DataSub)
                        {
                            foreach (ExGripData exgrData in grDatSub.SubData)
                            {
                                if (GripData.DrawType.DragImageGrip == exgrData.Status)
                                {
                                    bActive = true;
                                    m_aDrags.Add(new ExGripDrag(exgrData.SubentPath, this));
                                    break;
                                }
                            }
                            if (bActive == true)
                            {
                                break;
                            }
                        }
                    }

                    using (Teigha.GraphicsSystem.View pView = m_pDevice.ActiveView)
                    {
                        foreach (ExGripDrag grDrag in m_aDrags)
                        {
                            grDrag.notifyDragStarted();
                            grDrag.cloneEntity();
                            pView.Add(grDrag);
                        }
                    }

                    m_ptBasePoint = aKeys[0].Point;
                    m_ptLastPoint = m_ptBasePoint;
                }
            }
            else
            {
                return(false);
            }
            return(true);
        }
예제 #13
0
 public ExGripDataSubent()
 {
     m_entPath  = new FullSubentityPath();
     m_pSubData = new ExGripDataCollection();
 }
예제 #14
0
        void updateEntityGrips(ObjectId id)
        {
            using (Entity ent = (Entity)id.GetObject(OpenMode.ForRead))
            {
                removeEntityGrips(ent, id, false);
                try // grip points are implemented not for all entities
                {
                    ExGripDataCollection exGrDataColl;
                    GripDataCollection   grips = new GripDataCollection();
                    if (ent.GetGripPoints(grips, activeViewUnitSize(), GRIPSIZE, activeViewDirection(), GetGripPointsFlags.GripPointsOnly))
                    {
                        exGrDataColl = new ExGripDataCollection();
                        foreach (GripData gr in grips)
                        {
                            exGrDataColl.Add(new ExGripData(id, gr, gr.GripPoint, this));
                        }
                    }
                    else
                    {
                        exGrDataColl = new ExGripDataCollection();
                        Point3dCollection gripsPts = new Point3dCollection();
                        ent.GetGripPoints(gripsPts, null, null);
                        foreach (Point3d pt in gripsPts)
                        {
                            exGrDataColl.Add(new ExGripData(id, pt, this));
                        }
                    }

                    if (null != exGrDataColl)
                    {
                        ExGripDataExt dExt = new ExGripDataExt();
                        foreach (ExGripData grDat in exGrDataColl)
                        {
                            FullSubentityPath entPath;
                            if (grDat.entPath(out entPath))
                            {
                                bool bFound = false;
                                ExGripDataSubentCollection grSubColl = dExt.DataSub;
                                for (int j = 0; j < grSubColl.Count; j++)
                                {
                                    if (grSubColl[j].EntPath == entPath)
                                    {
                                        bFound = true;
                                        grSubColl[j].SubData.Add(grDat);
                                        break;
                                    }
                                }
                                if (!bFound)
                                {
                                    ExGripDataSubent se = new ExGripDataSubent();
                                    se.EntPath = entPath;
                                    se.SubData.Add(grDat);
                                    dExt.DataSub.Add(se);
                                }
                            }
                            else
                            {
                                if (dExt.DataArray == null)
                                {
                                    dExt.DataArray = new ExGripDataCollection();
                                }
                                dExt.DataArray.Add(grDat);
                            }
                        }

                        m_gripDataDict.Add(id, dExt);

                        foreach (ExGripData grData in exGrDataColl)
                        {
                            showGrip(grData);
                        }
                    }
                }
                catch (System.Exception)
                {
                    // just skip non-supported entities
                }
                ent.Highlight();
            }
        }