AutoCAD DevBlog: 2012

2012

02/15/2014

3DWalk through an AutoCAD Model

Here is a sample code to demonstrate the navigation through an AutoCAD model. In this sample code, the camera and target positions follow the selected spline entity which defines the navigation path.

Here is a recording of the output :

Here is the sample code :

[CommandMethod("MyWalk")]
public static void MyWalkMethod()
{
    Document doc
                = Application.DocumentManager.MdiActiveDocument;
    Database db = doc.Database;
    Editor ed = doc.Editor;
 
    PromptEntityOptions peo2
                = new PromptEntityOptions("\nSelect a spline :");
    peo2.SetRejectMessage(
        "Please select a spline for defining the 3D walk path");
    peo2.AddAllowedClass(
        typeof(Autodesk.AutoCAD.DatabaseServices.Spline), false);
    PromptEntityResult per2 = ed.GetEntity(peo2);
    if (per2.Status != PromptStatus.OK)
        return;
    ObjectId splineId = per2.ObjectId;
 
    int steps = 3000;
 
    Point3d position = Point3d.Origin;
    Point3d target = Point3d.Origin;
 
    // Create and add our message filter to know if
    // escape is pressed during walk.
    MyMessageFilter filter = new MyMessageFilter();
    System.Windows.Forms.Application.AddMessageFilter(filter);
 
    ViewportTableRecord backupVTR = new ViewportTableRecord();
 
    const double DIAG35MM = 42.0;
    double lensLength = 50.0;
    double projectionPlaneDistance = 50.0;
    double sp = 0.0;
    double ep = 0.0;
    double aspectRatio = 1.0;
 
    using (Transaction tr = db.TransactionManager.StartTransaction())
    {
        ViewTable viewTable = tr.GetObject(
                                            db.ViewTableId,
                                            OpenMode.ForWrite
                                            ) as ViewTable;
 
        ViewportTable vpTbl = tr.GetObject(
                                            db.ViewportTableId,
                                            OpenMode.ForRead
                                            ) as ViewportTable;
 
        ViewportTableRecord viewportTableRec = tr.GetObject
                                    (
                                            vpTbl["*Active"],
                                            OpenMode.ForRead
                                    ) as ViewportTableRecord;
 
        backupVTR.CopyFrom(viewportTableRec);
        aspectRatio =
            (viewportTableRec.Width / viewportTableRec.Height);
 
        Spline spline = tr.GetObject(
                                        splineId,
                                        OpenMode.ForWrite
                                    ) as Spline;
        sp = spline.StartParam;
        ep = spline.EndParam;
        spline.Visible = false;
 
        tr.Commit();
    }
 
    using (Transaction tr
                    = db.TransactionManager.StartTransaction())
    {
        Spline spline = tr.GetObject(
                                        splineId,
                                        OpenMode.ForRead
                                    ) as Spline;
 
        double paramincr = (ep - sp) / steps;
 
        for (double param = sp; param <= ep; param += paramincr)
        {
            if (filter.bCanceled == true)
            {
                ed.WriteMessage("\nWalk cancelled.");
                break;
            }
 
            position = spline.GetPointAtParameter(param);
            Vector3d tangent = spline.GetFirstDerivative(param);
            target = position +
                    tangent.GetNormal() * projectionPlaneDistance;
 
            double fieldHeight =
                    (projectionPlaneDistance * DIAG35MM) /
                    (lensLength *
                    Math.Sqrt(1.0 + aspectRatio * aspectRatio));
 
            double fieldWidth = aspectRatio * fieldHeight;
 
            using (ViewTableRecord vtr = new ViewTableRecord())
            {
                vtr.BackClipEnabled = false;
                vtr.BackClipDistance = 0.0;
                vtr.CenterPoint = Point2d.Origin;
                vtr.FrontClipAtEye = false;
                vtr.FrontClipEnabled = true;
                vtr.FrontClipDistance = projectionPlaneDistance;
                vtr.LensLength = lensLength;
                vtr.PerspectiveEnabled = true;
                vtr.RenderMode
                    = ViewTableRecordRenderMode.GouraudShaded;
                vtr.Target = target;
                vtr.ViewTwist = 0.0;
                vtr.ViewDirection = position - target;
                vtr.Width = fieldWidth;
                vtr.Height = fieldHeight;
 
                ed.SetCurrentView(vtr);
            }
 
            System.Threading.Thread.Sleep(10);
 
            // Check for user input events
            System.Windows.Forms.Application.DoEvents();
        }
 
        // Restore the view to what it was at start
        spline.UpgradeOpen();
        spline.Visible = true;
 
        ViewportTable vpTbl = tr.GetObject(
                                            db.ViewportTableId,
                                            OpenMode.ForRead
                                            ) as ViewportTable;
        ViewportTableRecord viewportTableRec = tr.GetObject(
                                            vpTbl["*Active"],
                                            OpenMode.ForWrite
                                    ) as ViewportTableRecord;
        viewportTableRec.UpgradeOpen();
        viewportTableRec.CopyFrom(backupVTR);
        ed.UpdateTiledViewportsFromDatabase();
 
        tr.Commit();
    }
 
    System.Windows.Forms.Application.RemoveMessageFilter(filter);
}
 
public class MyMessageFilter : System.Windows.Forms.IMessageFilter
{
    public const int WM_KEYDOWN = 0x0100;
    public bool bCanceled = false;
 
    public bool PreFilterMessage(ref System.Windows.Forms.Message m)
    {
        if (m.Msg == WM_KEYDOWN)
        {
            // Check for the Escape keypress
            System.Windows.Forms.Keys kc 
                = (System.Windows.Forms.Keys)
                (int)m.WParam & System.Windows.Forms.Keys.KeyCode;
            if (m.Msg == WM_KEYDOWN && 
                kc == System.Windows.Forms.Keys.Escape)
            {
                bCanceled = true;
            }
            // Return true to filter all keypresses
            return true;
        }
        // Return false to let other messages through
        return false;
    }
}

For the recording and testing of the sample code, I downloaded a nice sample drawing of a little house from here and made some minor changes to make it to more realistic. The modified sample drawing can be downloaded here :

Download House.dwg

To try the sample code, build the sample code and netload in AutoCAD. Open the sample drawing and run "MyWalk" command. Select the yellow spline when prompted for the 3D walk path. During the walk, press escape key to stop the navigation if you need to stop it.

Posted at 11:54 PM in .NET, 2012, 2013, 2014, AutoCAD, Balaji Ramamoorthy | Permalink | Comments (4)

02/09/2014

Making Custom entity GripMode aware

By Balaji Ramamoorthy

Here is a sample project that implements a custom entity which embeds a Polyline. The custom entity enables GripModes that operate on the embedded entity by making the implementation of "subMoveGripPointsAt" method GripMode aware. In the attached project, the grip modes for the custom entity are same as that of the embedded Polyline, but if your custom entity has multiple embedded entities, you can extend the implementation to expose more GripModes for the custom entity on similar lines.

Here is a portion of the relevant code and the sample project can be downloaded from here : MultiModeGrip_EmbeddedPolyline

//ContainerEntity.h 
 
// Custom grip app data to identify the grips 
class MyGripAppData : public AcDbObject
{
public:
   ACRX_DECLARE_MEMBERS(MyGripAppData) ;
 
   Adesk::UInt32 m_GripNumber;
 
   MyGripAppData(){ m_GripNumber = 0; }
 
   MyGripAppData(int gripNumber){ m_GripNumber = gripNumber; }
};
 
// Container custom entity that embeds a polyline
class DLLIMPEXP AdskContainerEntity : public AcDbEntity 
{
 
public:
    ACRX_DECLARE_MEMBERS(AdskContainerEntity) ;
 
protected:
    static Adesk::UInt32 kCurrentVersionNumber ;
 
public:
    AdskContainerEntity () ;
    virtual ~AdskContainerEntity () ;
 
    AcDbPolyline *m_pPolyline; // Embedded Polyline
 
    // GripMode for use in "subMoveGripPointsAt" 
    // which is GripMode aware. 
    Adesk::UInt32 m_pCurrentGripMode; 
 
    // To remove or to add after depending on the GripMode
    Adesk::UInt32 m_iVertexNumber;    
 
    // Coordinates of the new vertex point to 
    // add if the GripMode is "Add Vertex"
    AcGePoint2d m_NewVertexCoord;     
 
protected:
    virtual Adesk::Boolean subWorldDraw (AcGiWorldDraw *mode) ;
    virtual Acad::ErrorStatus subTransformBy
                                (const AcGeMatrix3d& xform);
 
    Acad::ErrorStatus dwgInFields (AcDbDwgFiler *pFiler);
    Acad::ErrorStatus dwgOutFields (AcDbDwgFiler *pFiler) const;
 
    //- Grip points protocol
    virtual Acad::ErrorStatus subGetGripPoints (
                                AcDbGripDataPtrArray &grips, 
                                const double curViewUnitSize, 
                                const int gripSize, 
                                const AcGeVector3d &curViewDir, 
                                const int bitflags) const ;
 
    virtual Acad::ErrorStatus subMoveGripPointsAt(
                            const AcDbVoidPtrArray& gripAppData, 
                            const AcGeVector3d& offset, 
                            const int bitflags);
};
 
 
// ContainerEntity.cpp : Implementation of AdskContainerEntity
 
AdskContainerEntity::AdskContainerEntity () : AcDbEntity () 
{
    m_pPolyline = NULL;
    m_pCurrentGripMode = 0;
    m_iVertexNumber = 0;
}
 
AdskContainerEntity::~AdskContainerEntity () 
{
    if (m_pPolyline)
    {
        delete m_pPolyline;
        m_pPolyline = 0;
    }
}
 
Acad::ErrorStatus AdskContainerEntity::dwgInFields
                                        (AcDbDwgFiler *pFiler) 
{
    assertWriteEnabled () ;
 
    Acad::ErrorStatus es = AcDbEntity::dwgInFields (pFiler) ;
    if ( es != Acad::eOk )
        return (es) ;
 
    Adesk::UInt32 version =0 ;
    if ( (es =pFiler->readUInt32 (&version)) != Acad::eOk )
        return (es) ;
 
    if ( version > AdskContainerEntity::kCurrentVersionNumber)
        return (Acad::eMakeMeProxy) ;
 
    // Read params
    Adesk::UInt32 numVerts = 0;
    pFiler->readUInt32(&numVerts);
 
    AcGePoint3dArray points;
    for(int i = 0; i < numVerts; i++)
    {
        AcGePoint3d pt;
        pFiler->readPoint3d(&pt);
        points.append(pt);
    }
 
    if (m_pPolyline)
    {
        delete m_pPolyline;
        m_pPolyline = 0;
    }
 
    m_pPolyline = new AcDbPolyline(numVerts);         
    m_pPolyline->setDatabaseDefaults();
 
    for(int i = 0; i < numVerts; i++)
    {
        AcGePoint3d pt(points[i]);
        m_pPolyline->addVertexAt(i, AcGePoint2d(pt.x, pt.y));
    }
 
    return (pFiler->filerStatus ()) ;
}
 
 
Acad::ErrorStatus AdskContainerEntity::dwgOutFields 
                                (AcDbDwgFiler *pFiler) const 
{
    assertReadEnabled () ;
 
    Acad::ErrorStatus es = AcDbEntity::dwgOutFields (pFiler) ;
    if ( es != Acad::eOk )
        return (es) ;
 
    if ( (es =pFiler->writeUInt32 
        (AdskContainerEntity::kCurrentVersionNumber)) 
                                                != Acad::eOk )
        return (es) ;
 
    // Output params
    if(m_pPolyline)
    {
        Adesk::UInt32 numVerts = m_pPolyline->numVerts();
 
        pFiler->writeUInt32(numVerts);
 
        for(int i = 0; i < numVerts; i++)
        {
            AcGePoint3d pt;
            m_pPolyline->getPointAt(i, pt);
            pFiler->writePoint3d(pt); 
        }
    }
 
    return (pFiler->filerStatus ()) ;
}
 
Adesk::Boolean AdskContainerEntity::subWorldDraw 
                                        (AcGiWorldDraw *mode) 
{
    assertReadEnabled () ;
 
    // Draw the polyline
    if(m_pPolyline)
        mode->geometry().pline (*m_pPolyline);
 
    return (AcDbEntity::subWorldDraw (mode)) ;
}
 
Acad::ErrorStatus AdskContainerEntity::subGetGripPoints(
                     AcDbGripDataPtrArray &grips, 
                     const double curViewUnitSize, 
                     const int gripSize,  
                     const AcGeVector3d &curViewDir, 
                     const int bitflags ) const 
{
    assertReadEnabled () ;
 
    // Return the vertices of the embedded polyline as 
    // grip points
    if(m_pPolyline)
    {
        Adesk::UInt32 numVerts = m_pPolyline->numVerts();
        for(int i = 0; i < numVerts; i++)
        {
            AcGePoint3d pt;
            m_pPolyline->getPointAt(i, pt);
 
            AcDbGripData * pGripData = new AcDbGripData();
            pGripData->setAppData(new MyGripAppData(i));
            pGripData->setGripPoint(pt); 
            grips.append(pGripData);
        }
    }
    return Acad::eOk;
}
 
// Grip mode aware implementation of subMoveGripPointsAt
// Depending on the current grip mode, it stretches / adds or
// removes vertices from the embedded polyline
 Acad::ErrorStatus AdskContainerEntity::subMoveGripPointsAt(
                         const AcDbVoidPtrArray& gripAppData, 
                         const AcGeVector3d& offset, 
                         const int bitflags)
 {
    assertWriteEnabled () ;
 
    if(m_pPolyline)
    {
        switch(m_pCurrentGripMode)
        {
            case 0: // Stretch 
            {
                for (int i = 0; i < gripAppData.length(); i++)
                {
                    MyGripAppData *pMyGripAppData 
                        = static_cast<MyGripAppData *>
                                        (gripAppData.at(i));
                    if(pMyGripAppData != NULL)
                    {
                        int num = pMyGripAppData->m_GripNumber;
 
                        AcGePoint3d pt;
                        m_pPolyline->getPointAt(num, pt);
 
                        AcGeMatrix3d mat 
                                    = AcGeMatrix3d::kIdentity;
                        mat = mat.translation(offset);
 
                        pt = pt.transformBy(mat);
 
                        m_pPolyline->setPointAt(
                                num, AcGePoint2d(pt.x, pt.y));
                    }
                }
                break;
            }
 
            case 1: // Add Vertex
            {
                m_pPolyline->addVertexAt(
                    m_iVertexNumber+1, 
                    AcGePoint2d(m_NewVertexCoord.x, 
                                m_NewVertexCoord.y)
                                        );
 
                // Reset to default GripMode
                m_pCurrentGripMode = 0; 
                break;
            }
 
            case 2: // Remove Vertex
            {
                if(m_iVertexNumber < m_pPolyline->numVerts())
                    m_pPolyline->removeVertexAt(m_iVertexNumber); 
 
                // Reset to default GripMode
                m_pCurrentGripMode = 0; 
                break;
            }
        }
    }
    return Acad::eOk;
 }
 
Acad::ErrorStatus AdskContainerEntity::subTransformBy(const AcGeMatrix3d& xform)
{
    assertWriteEnabled();
 
    // Transform the polyline
    if(m_pPolyline)
        m_pPolyline->transformBy(xform);
 
    return (AcDbEntity::subTransformBy(xform));
}
 
 
// ContainerEntityMultiModesGripPE.h
 
#include "dbMultiModesGrip.h"
 
// GripModePE implementation for the custom entity
// This exposes 3 gripmodes. 
// Stretch vertex
// Add Vertex
// Remove Vertex
class AdskContainerEntityMultiModesGripPE : public AcDbMultiModesGripPE
{
private:
    static AcDbMultiModesGripPE::GripMode _currentGripMode;
 
public:
    ACRX_DECLARE_MEMBERS(AdskContainerEntityMultiModesGripPE);
 
    AdskContainerEntityMultiModesGripPE();
    ~AdskContainerEntityMultiModesGripPE();
 
    static AcDbObjectId getLastModifiedEntId();
    static Adesk::UInt32 getVertexNumberToAdd();
 
    virtual bool getGripModes(    AcDbEntity* pThis, 
                                AcDbGripData* pGripData, 
                                AcArray<GripMode>& modes, 
                                unsigned int& curMode
                             ) const;
 
    virtual unsigned int mode(    AcDbEntity* pThis, 
                                AcDbGripData* pGripData
                             ) const;
 
    virtual AcDbMultiModesGripPE::GripMode modeEx(
            AcDbEntity* pThis, AcDbGripData* pGripData) const;
 
    virtual bool setMode(    AcDbEntity* pThis, 
                            AcDbGripData* pGripData, 
                            unsigned int newMode);
 
    virtual AcDbMultiModesGripPE::GripType gripType(
            AcDbEntity* pThis, AcDbGripData* pGripData) const;
 
    virtual void reset(AcDbEntity* pThis);
};
 
// ContainerEntityMultiModesGripPE.cpp
// GripModePE implementation for the custom entity
// This exposes 3 gripmodes. 
// Stretch vertex
// Add Vertex
// Remove Vertex
 
AdskContainerEntityMultiModesGripPE::
                        AdskContainerEntityMultiModesGripPE()
{
    // Default grip mode : Stretch Vertex
    _currentGripMode.Mode = 0;
    _currentGripMode.DisplayString = AcString("Stretch Vertex");
}
 
AdskContainerEntityMultiModesGripPE::
                        ~AdskContainerEntityMultiModesGripPE()
{
}
 
// Returns the possible grip modes
// Stretch vertex
// Add Vertex
// Remove Vertex
bool AdskContainerEntityMultiModesGripPE::getGripModes(
                                AcDbEntity* pThis, 
                                AcDbGripData* pGripData, 
                                AcArray<GripMode>& modes, 
                                unsigned int& curMode) const 
{
    // "Stretch Vertex" mode
    GripMode gripMode1;
    gripMode1.Mode = 0;
    gripMode1.DisplayString = AcString("Stretch Vertex");
    gripMode1.ActionType = AcDbMultiModesGripPE::kDragOn;
 
    modes.append(gripMode1);
 
    // "Add Vertex" mode
    GripMode gripMode2;
    gripMode2.Mode = 1;
    gripMode2.DisplayString = AcString("Add Vertex");
    gripMode2.ActionType = AcDbMultiModesGripPE::kImmediate;
 
    modes.append(gripMode2);
 
    // "Remove Vertex" mode to be available only if there are 
    // more than 2 vertices in the polyline.
    AdskContainerEntity *pContEnt 
                           = AdskContainerEntity::cast(pThis);
    if(pContEnt->m_pPolyline != NULL)
    {
        if(pContEnt->m_pPolyline->numVerts() > 2)
        {
            GripMode gripMode3;
            gripMode3.Mode = 2;
            gripMode3.DisplayString = AcString("Remove Vertex");
            gripMode3.ActionType 
                        = AcDbMultiModesGripPE::kImmediate;
 
            modes.append(gripMode3);
        }
    }
 
    // "Stretch Vertex" is the current mode
    curMode = 0;
 
    return true;
}
 
// Gets the current mode identifier.
unsigned int AdskContainerEntityMultiModesGripPE::mode(
            AcDbEntity* pThis, AcDbGripData* pGripData) const
{
    return _currentGripMode.Mode; 
}
 
// Return the current mode.
AcDbMultiModesGripPE::GripMode 
AdskContainerEntityMultiModesGripPE::modeEx(
            AcDbEntity* pThis, AcDbGripData* pGripData) const 
{
    return _currentGripMode;
}
 
// Sets the current mode.
bool AdskContainerEntityMultiModesGripPE::setMode(
                AcDbEntity* pThis, 
                AcDbGripData* pGripData, unsigned int newMode)
{
    bool retStatus = true;
 
    _currentGripMode.Mode = newMode;
 
    AcDbObjectId entId = pThis->id();
    AdskContainerEntity *pContEnt 
                            = AdskContainerEntity::cast(pThis);
    pContEnt->m_pCurrentGripMode = newMode;
 
    switch(newMode)
    {
        case 0:
        {
            _currentGripMode.DisplayString 
                                 = AcString("Stretch Vertex"); 
            break;
        }
 
        case 1:
        {
            _currentGripMode.DisplayString 
                                     = AcString("Add Vertex");
 
            // Create a temporary copy of the embedded Polyline for jigging purposes
            AcDbPolyline *pPolyTemp = AcDbPolyline::cast(pContEnt->m_pPolyline->clone());
 
            MyGripAppData *pMyGripAppData = static_cast<MyGripAppData *>(pGripData->appData());
            if(pMyGripAppData != NULL)
            {
                // Adding vertex requires a Jig
                PolyLineVertexAddJig *pPolyAddVertedJig 
                    = new PolyLineVertexAddJig(
                      pPolyTemp, pMyGripAppData->m_GripNumber);
                AcEdJig::DragStatus status = pPolyAddVertedJig->doIt();
                if(status != AcEdJig::kCancel)
                {
                    pContEnt->m_iVertexNumber 
                                = pMyGripAppData->m_GripNumber;
                    pContEnt->m_NewVertexCoord 
                           = pPolyAddVertedJig->AddedVertex();
                }
                else
                {
                    // Cancel setting the GripMode as the 
                    // Jig was canceled 
                    retStatus = false; 
                }
 
                delete pPolyAddVertedJig;
            }
 
            break;
        }
 
        case 2:
        {
            _currentGripMode.DisplayString 
                                  = AcString("Remove Vertex");
 
            MyGripAppData *pMyGripAppData 
                = static_cast<MyGripAppData *>(
                                        pGripData->appData());
            if(pMyGripAppData != NULL)
            {
                pContEnt->m_iVertexNumber 
                               = pMyGripAppData->m_GripNumber;
            }
            break;
        }
    }
 
    return retStatus;
}
 
// Gets the grip type of a given grip.
AcDbMultiModesGripPE::GripType 
    AdskContainerEntityMultiModesGripPE::gripType(
            AcDbEntity* pThis, AcDbGripData* pGripData) const 
{
    return AcDbMultiModesGripPE::kPrimary;  
}
 
// resets current mode to default 
void AdskContainerEntityMultiModesGripPE::reset(AcDbEntity* pThis)
{
    _currentGripMode.Mode = 0;
    _currentGripMode.DisplayString = AcString("Stretch Vertex");
}
 
 
// PolyLineVertexAddJig.h
// Polyline jig for adding a new vertex
 
class PolyLineVertexAddJig : public AcEdJig
{
public:
    PolyLineVertexAddJig();
    ~PolyLineVertexAddJig();
    PolyLineVertexAddJig(
              AcDbPolyline *pPoly, Adesk::UInt32 vertexToAdd);
 
    AcEdJig::DragStatus doIt();
    virtual DragStatus sampler();
    virtual Adesk::Boolean update();
 
    AcGePoint2d AddedVertex();
 
    virtual AcDbEntity* entity() const;
 
private:
    AcDbPolyline *m_pPoly;
    Adesk::UInt32 m_nVertexToAdd;
 
    AcGePoint3d vertexPointTemp;
    AcGePoint3d vertexPoint;
 
    Adesk::Boolean addNew;
};
 
// PolyLineVertexAddJig.cpp
 
#include "StdAfx.h"
#include "PolyLineVertexAddJig.h"
 
PolyLineVertexAddJig::PolyLineVertexAddJig()
{
    m_pPoly = NULL;
    vertexPointTemp = AcGePoint3d::kOrigin;
    vertexPoint = AcGePoint3d::kOrigin;
    addNew = Adesk::kTrue;
}
 
PolyLineVertexAddJig::PolyLineVertexAddJig(
               AcDbPolyline *pPoly, Adesk::UInt32 vertexToAdd)
{
    // Polyline to jig
    m_pPoly = pPoly;
 
    // Index to mark the position of the new vertex
    m_nVertexToAdd = vertexToAdd;
 
    // To keep track of the coordinates during jigging
    vertexPointTemp = AcGePoint3d::kOrigin;
    vertexPoint = AcGePoint3d::kOrigin;
 
    // To know if we already added a vertex during jigging
    addNew = Adesk::kTrue;
}
 
PolyLineVertexAddJig::~PolyLineVertexAddJig()
{
    // Cleanup
    if(m_pPoly)
    {
        delete m_pPoly;
        m_pPoly = NULL;
    }
}
 
// Start the jig
AcEdJig::DragStatus PolyLineVertexAddJig::doIt()
{
    AcEdJig::DragStatus stat = AcEdJig::kCancel;
 
    if(m_pPoly)
    {
        setDispPrompt(ACRX_T("\n Select vertex point : "));
        stat = drag();
    }
 
    return stat;
}
 
AcEdJig::DragStatus PolyLineVertexAddJig::sampler()
{
    DragStatus stat;
    setUserInputControls((UserInputControls)
        (AcEdJig::kAccept3dCoordinates
         | AcEdJig::kNoNegativeResponseAccepted
         | AcEdJig::kNoZeroResponseAccepted));
 
    // Get a point input for the coordinates
    stat = acquirePoint(vertexPoint);
    if (vertexPointTemp != vertexPoint)
        vertexPointTemp = vertexPoint;
    else if (stat == AcEdJig::kNormal)
        return AcEdJig::kNoChange;
 
    return stat;
}
 
Adesk::Boolean PolyLineVertexAddJig::update()
{
    if(m_pPoly)
    {
        if(addNew)
        {// First time, add a new vertex
            m_pPoly->addVertexAt(
                m_nVertexToAdd+1, 
                AcGePoint2d(vertexPoint.x, vertexPoint.y));
        }
        else
        { // Update the coordinates of the 
          // previously added vertex
            if(m_nVertexToAdd < m_pPoly->numVerts())
            {
                m_pPoly->setPointAt(
                    m_nVertexToAdd+1, 
                    AcGePoint2d(vertexPoint.x, vertexPoint.y));
            }
        }
    }
 
    if(addNew)
        addNew = Adesk::kFalse;
 
    return Adesk::kTrue;
}
 
AcDbEntity* PolyLineVertexAddJig::entity() const
{
    return m_pPoly;
}
 
// To get the coordinates of the vertex added by this jig
AcGePoint2d PolyLineVertexAddJig::AddedVertex()
{
    return AcGePoint2d(vertexPoint.x, vertexPoint.y);
}

Posted at 10:40 PM in 2012, 2013, 2014, AutoCAD, Balaji Ramamoorthy, ObjectARX | Permalink | Comments (1)

12/30/2013

Running a Tool from ToolPalette

By Balaji Ramamoorthy

Here is a sample code to run the "Anchor Rod - Imperial" tool available in the "Mechanical" ToolPalette in AutoCAD. It iterates the catalog items and executes the tool. It is similar to what a left mouse button click on the tool would do using the AutoCAD UI.

AcString toolName2Run = "Anchor Rod - Imperial";
 
INT_PTR catalogCount = AcTcGetManager()->GetCatalogCount();
for( int catIndex = 0 ; 
    (catIndex < catalogCount) && ! toolExecuted ; 
     catIndex ++) 
{
    AcTcCatalogItem *pCatItem 
                    = AcTcGetManager()->GetCatalog(catIndex);
 
    INT_PTR nChildren1 = pCatItem->GetChildCount();
    for( int childIndex1 = 0 ; 
         (childIndex1 < nChildren1) && ! toolExecuted; 
         childIndex1++ ) 
    {
        AcTcCatalogItem *pCatItem1 
                            = pCatItem->GetChild(childIndex1);
 
        INT_PTR nChildren2 = pCatItem1->GetChildCount();
        for( int childIndex2 = 0; 
            (childIndex2 < nChildren2) && ! toolExecuted ; 
            childIndex2++ ) 
        {
            AcTcCatalogItem *pCatItem2 
                        = pCatItem1->GetChild(childIndex2);
 
            CatalogItemType ItemType = pCatItem2->GetType();
            if(ItemType == kItemTool ) 
            {
                AcTcTool *pTool 
                        = static_cast<AcTcTool *>(pCatItem2);
                if (pTool != NULL)
                {
                    ACHAR szToolName[MAX_PATH]; 
                    pTool->GetName(szToolName, MAX_PATH); 
                    if(toolName2Run.compareNoCase(
                                   AcString(szToolName)) == 0) 
                    { 
                        int nFlag = 0; // LButton clicked
                        HWND hWnd = NULL;
                        POINT point;
                        point.x = 0; point.y = 0; 
                        DWORD dwKeyState = 0; 
                        toolExecuted 
                            = pTool->Execute( nFlag, 
                                              hWnd, 
                                              point, 
                                              dwKeyState
                                            ); 
                    }
                }
            }
        }
    }
}

Posted at 05:11 AM in 2012, 2013, 2014, AutoCAD, Balaji Ramamoorthy, ObjectARX | Permalink | Comments (0)

12/18/2013

Grip context menu using AcDbMultiModesGripPE

By Balaji Ramamoorthy

Here is a sample project that implements a grip context menu for a custom entity using the AcDbMultiModesGripPE. It demonstrates the use of multi-mode grips to acquire inputs that is relevant to the custom entity.

To make it fun, I have created a custom entity that resembles a tree. Its grip context menu displays two modes - "Spring" and "Winter". After the tree custom entity is created, the context menu will appear when the grip turns warm. Selecting "Spring" will ensure that the tree has leaves and selecting "Winter" will make the tree shed its leaves.

In this case, the modes are not relevant to grip editing and since we do not want the grip to start dragging when clicked, the action type of the modes are set as command. After the mode is selected, the command gets invoked by AutoCAD. In the command implementation, we ensure that the tree updates its display based on the mode that was selected. I would have liked to have a check mark next to the current mode, but the API does not have a way to do that at present and we have a wish-list item created for it with our engineering team.

Here is the relevant code and the complete sample project can be downloaded from the link below :

// Header
// TreeMultiModesGripPE.h
 
#pragma once
 
#include "dbMultiModesGrip.h"
 
class AdskTreeMultiModesGripPE : public AcDbMultiModesGripPE
{
private:
    static AcDbMultiModesGripPE::GripMode _currentGripMode;
    static AcDbObjectId _lastModifiedEntId;
 
public:
    ACRX_DECLARE_MEMBERS(AdskTreeMultiModesGripPE);
 
    AdskTreeMultiModesGripPE();
    ~AdskTreeMultiModesGripPE();
    static AcDbObjectId getLastModifiedEntId();
 
    virtual bool getGripModes(AcDbEntity* pThis, 
                              AcDbGripData* pGripData, 
                              AcArray<GripMode>& modes, 
                              unsigned int& curMode) const;
 
    virtual unsigned int mode(AcDbEntity* pThis, 
                              AcDbGripData* pGripData) const;
 
    virtual AcDbMultiModesGripPE::GripMode modeEx(
                AcDbEntity* pThis, 
                AcDbGripData* pGripData) const;
 
    virtual bool setMode(
                AcDbEntity* pThis, 
                AcDbGripData* pGripData, 
                unsigned int newMode);
 
    virtual AcDbMultiModesGripPE::GripType gripType(
            AcDbEntity* pThis, AcDbGripData* pGripData) const;
 
    virtual void reset(AcDbEntity* pThis);
};
 
 
// Implementation
// TreeMultiModesGripPE.cpp
 
#include "StdAfx.h"
#include "dbMultiModesGrip.h"
#include "TreeMultiModesGripPE.h"
#include "AdskTree.h"
 
ACRX_CONS_DEFINE_MEMBERS(AdskTreeMultiModesGripPE, 
                         AcDbMultiModesGripPE, 1);
 
AcDbMultiModesGripPE::GripMode 
                    AdskTreeMultiModesGripPE::_currentGripMode;
 
AcDbObjectId AdskTreeMultiModesGripPE::_lastModifiedEntId 
                                        = AcDbObjectId::kNull;
 
AdskTreeMultiModesGripPE::AdskTreeMultiModesGripPE()
{
    // Default grip mode
    _currentGripMode.Mode = 0;
    _currentGripMode.DisplayString = AcString("Spring");
}
 
AdskTreeMultiModesGripPE::~AdskTreeMultiModesGripPE()
{
}
 
// Returns the possible grip modes
bool AdskTreeMultiModesGripPE::getGripModes(
                                AcDbEntity* pThis, 
                                AcDbGripData* pGripData, 
                                AcArray<GripMode>& modes, 
                                unsigned int& curMode) const 
{
    GripMode gripMode1;
    gripMode1.Mode = 0;
    gripMode1.DisplayString = AcString("Spring");
    gripMode1.ActionType = GripActionType::kCommand;
    gripMode1.CommandString = AcString("ModeSwitchCmd ");
 
    modes.append(gripMode1);
 
    GripMode gripMode2;
    gripMode2.Mode = 1;
    gripMode2.DisplayString = AcString("Winter");
    gripMode2.ActionType = GripActionType::kCommand;
    gripMode2.CommandString = AcString("ModeSwitchCmd ");
 
    modes.append(gripMode2);
 
    curMode = 0;
 
    return true;
}
 
// Gets the current mode identifier.
unsigned int AdskTreeMultiModesGripPE::mode(
                                AcDbEntity* pThis, 
                                AcDbGripData* pGripData) const
{
    return _currentGripMode.Mode; 
}
 
// Return the current mode.
AcDbMultiModesGripPE::GripMode 
    AdskTreeMultiModesGripPE::modeEx(
            AcDbEntity* pThis, AcDbGripData* pGripData) const 
{
    return _currentGripMode;
}
 
// Sets the current mode.
bool AdskTreeMultiModesGripPE::setMode(
            AcDbEntity* pThis, 
            AcDbGripData* pGripData, 
            unsigned int newMode)
{
    _currentGripMode.Mode = newMode;
 
    AcDbObjectId entId = pThis->id();
    AdskTree *pTree = AdskTree::cast(pThis);
 
    switch(newMode)
    {
        case 0:
            acutPrintf(ACRX_T("\nSpring season, growing leaves !"));
 
            _currentGripMode.DisplayString = AcString("Spring"); 
            pTree->setSeason(AcString("Spring"));
            // For graphics update
            _lastModifiedEntId = pTree->id();
 
            break;
 
        case 1:
            acutPrintf(ACRX_T("\nWinter season, shedding leaves !"));
 
            _currentGripMode.DisplayString = AcString("Winter");
            pTree->setSeason(AcString("Winter"));
            // For graphics update
            _lastModifiedEntId = pTree->id();
 
            break;
    }
    return true;
}
 
// Gets the grip type of a given grip.
AcDbMultiModesGripPE::GripType 
AdskTreeMultiModesGripPE::gripType(
            AcDbEntity* pThis, AcDbGripData* pGripData) const 
{
    return AcDbMultiModesGripPE::GripType::kPrimary;  
}
 
// To retrieve the objectId of the tree entity 
// for graphics update
AcDbObjectId AdskTreeMultiModesGripPE::getLastModifiedEntId()
{
    return _lastModifiedEntId;
}
 
// resets current mode to default 
void AdskTreeMultiModesGripPE::reset(AcDbEntity* pThis)
{
    _currentGripMode.Mode = 0;
    _currentGripMode.DisplayString = AcString("Spring");
}
 
 
 
// Header for custom entity
// AsdkTree.h
 
#pragma once
 
#ifdef MULTIMODEGRIPSIMPLESAMPLE_MODULE
#define DLLIMPEXP __declspec(dllexport)
#else
#define DLLIMPEXP
#endif
 
//-----------------------------------------------------------------------------
#include "dbmain.h"
 
//-----------------------------------------------------------------------------
class DLLIMPEXP AdskTree : public AcDbEntity 
{
 
public:
    ACRX_DECLARE_MEMBERS(AdskTree) ;
 
protected:
    static Adesk::UInt32 kCurrentVersionNumber ;
 
private:
    AcGePoint3d _basePoint;
    AcString _season;
 
    void BuildSubTree(
        AcGeLineSeg3d *pMainBranch, 
        int level, 
        AcGiWorldDraw *mode, 
        Adesk::Boolean flower = Adesk::kFalse);
 
public:
    AdskTree () ;
    virtual ~AdskTree () ;
 
    // Sets the season status
    void setSeason(AcString season);
 
    // Sets the insertion point
    void setBasePoint(AcGePoint3d basePoint);
 
    //----- AcDbObject protocols
    //- Dwg Filing protocol
    virtual Acad::ErrorStatus 
                    dwgOutFields (AcDbDwgFiler *pFiler) const ;
    virtual Acad::ErrorStatus 
                        dwgInFields (AcDbDwgFiler *pFiler) ;
 
    //----- AcDbEntity protocols
    //- Graphics protocol
protected:
    virtual Adesk::Boolean subWorldDraw (AcGiWorldDraw *mode) ;
    virtual Acad::ErrorStatus 
                    subTransformBy(const AcGeMatrix3d& xform);
 
    //- Grip points protocol
    virtual Acad::ErrorStatus subGetGripPoints (
                                AcDbGripDataPtrArray &grips, 
                                const double curViewUnitSize, 
                                const int gripSize, 
                                const AcGeVector3d &curViewDir, 
                                const int bitflags) const ;
 
    virtual Acad::ErrorStatus subMoveGripPointsAt (
        const AcDbVoidPtrArray &gripAppData, 
        const AcGeVector3d &offset, const int bitflags) ;
};
 
#ifdef MULTIMODEGRIPSIMPLESAMPLE_MODULE
ACDB_REGISTER_OBJECT_ENTRY_AUTO(AdskTree)
#endif
 
 
// Implementation of the custom entity
// AdskTree.cpp 
 
#include "StdAfx.h"
#include "AdskTree.h"
 
Adesk::UInt32 AdskTree::kCurrentVersionNumber =1 ;
 
ACRX_DXF_DEFINE_MEMBERS (
    AdskTree, AcDbEntity,
    AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent, 
    AcDbProxyEntity::kNoOperation, ADSKTREE,
ADSKMULTIMODEGRIPSIMPLESAMPLEAPP
|Product Desc:     A description for your object
|Company:          Your company name
|WEB Address:      Your company WEB site address
)
 
AdskTree::AdskTree () : AcDbEntity () 
{
    _basePoint = AcGePoint3d::kOrigin; 
    _season = AcString("Spring");
}
 
AdskTree::~AdskTree () 
{
}
 
//----- AcDbObject protocols
//- Dwg Filing protocol
Acad::ErrorStatus AdskTree::dwgOutFields(AcDbDwgFiler *pFiler) 
                                                    const {
    assertReadEnabled () ;
    //----- Save parent class information first.
    Acad::ErrorStatus es =AcDbEntity::dwgOutFields (pFiler) ;
    if ( es != Acad::eOk )
        return (es) ;
    //----- Object version number needs to be saved first
    if ( (es =pFiler->writeUInt32 
            (AdskTree::kCurrentVersionNumber)) != Acad::eOk )
        return (es) ;
 
    //----- Output params
    pFiler->writePoint3d(_basePoint);
 
    return (pFiler->filerStatus ()) ;
}
 
Acad::ErrorStatus AdskTree::dwgInFields(AcDbDwgFiler *pFiler)
{
    assertWriteEnabled () ;
    //----- Read parent class information first.
    Acad::ErrorStatus es =AcDbEntity::dwgInFields (pFiler) ;
    if ( es != Acad::eOk )
        return (es) ;
    //----- Object version number needs to be read first
    Adesk::UInt32 version =0 ;
    if ( (es =pFiler->readUInt32 (&version)) != Acad::eOk )
        return (es) ;
    if ( version > AdskTree::kCurrentVersionNumber )
        return (Acad::eMakeMeProxy) ;
 
    //----- Read params
    pFiler->readPoint3d(&_basePoint);
 
    return (pFiler->filerStatus ()) ;
}
 
 
//----- AcDbEntity protocols
Adesk::Boolean AdskTree::subWorldDraw (AcGiWorldDraw *mode) 
{
    assertReadEnabled () ;
 
    AcGeLineSeg3d mainBranch(
        _basePoint, 
        AcGePoint3d(_basePoint.x,_basePoint.y+10.0,_basePoint.z));
 
    AcDbLine *pLine1 = new AcDbLine(
            mainBranch.startPoint(), mainBranch.endPoint());
    mode->geometry().draw(pLine1);
    delete pLine1;
 
    int level = 0;
    BuildSubTree(&mainBranch, level, mode);
 
    return (AcDbEntity::subWorldDraw (mode)) ;
}
 
void AdskTree::setBasePoint(AcGePoint3d basePoint)
{
    _basePoint = basePoint;
}
 
void AdskTree::setSeason(AcString season)
{
    _season = season;
}
 
void AdskTree::BuildSubTree(AcGeLineSeg3d *pMainBranch, 
                            int level, 
                            AcGiWorldDraw *mode, 
                            Adesk::Boolean flower)
{
    if(mode->isDragging() && level >= 2)
        return; // Light weight for dragging
 
    if(level >= 3)
    {
        if(_season == AcString("Spring"))
        {
            AcDbCircle *pLeaf = new AcDbCircle(
                pMainBranch->endPoint(), 
                AcGeVector3d::kZAxis, 
                pMainBranch->length() * 0.2); 
 
            if(flower)
                pLeaf->setColorIndex(1);
            else
                pLeaf->setColorIndex(2); 
            mode->geometry().draw(pLeaf);
            delete pLeaf;
        }
        return;
    }
 
    int subLevel = level + 1;
    AcGePoint3d sp = AcGePoint3d::kOrigin;
    AcGePoint3d ep = AcGePoint3d::kOrigin;
    AcGeInterval intrvl;
    pMainBranch->getInterval(intrvl, sp, ep);
    double len = pMainBranch->length();
 
    AcGePoint3dArray pts;
    pMainBranch->getSamplePoints(5, pts);
 
    const double PI = 3.1415926535897932385;
    int cnt = 1;
    if(level == 0)
        cnt = 2;
    for(;cnt < 5; cnt++)
    {
        AcGeVector3d dir = pMainBranch->direction().normalize(); 
        AcGePoint3d refPt1 = pts[cnt];
 
        if(cnt == 4)
        {
            AcGePoint3d refPt2 = refPt1 + (len * 0.5) * dir;
 
            AcGeLineSeg3d branch1(refPt1, refPt2);
            AcDbLine *pBranchLine1 = new AcDbLine(refPt1, refPt2);
            mode->geometry().draw(pBranchLine1);
            delete pBranchLine1;
            BuildSubTree(&branch1, subLevel, mode, Adesk::kTrue);
        }
        else
        {
            AcGePoint3d refPt2 = refPt1 + 
                (len * 0.5) * dir.transformBy(
                AcGeMatrix3d::rotation(    PI * 0.25, 
                                        AcGeVector3d::kZAxis, 
                                        refPt1
                                       ));
 
            AcGeLineSeg3d branch1(refPt1, refPt2);
            AcDbLine *pBranchLine1 = new AcDbLine(refPt1, refPt2);
            mode->geometry().draw(pBranchLine1);
            delete pBranchLine1;
            BuildSubTree(&branch1, subLevel, mode);
 
            dir = pMainBranch->direction().normalize(); 
            refPt2 = refPt1 + (len * 0.5) * 
                dir.transformBy(AcGeMatrix3d::rotation(
                -PI * 0.25, AcGeVector3d::kZAxis, refPt1));
 
            AcGeLineSeg3d branch2(refPt1, refPt2);
            AcDbLine *pBranchLine2 = new AcDbLine(refPt1, refPt2);
            mode->geometry().draw(pBranchLine2);
            delete pBranchLine2;
            BuildSubTree(&branch2, subLevel, mode);
        }
    }
}
 
Acad::ErrorStatus AdskTree::subGetGripPoints ( 
    AcDbGripDataPtrArray &grips, 
    const double curViewUnitSize, 
    const int gripSize,  
    const AcGeVector3d &curViewDir, 
    const int bitflags ) const 
{
    assertReadEnabled () ;
 
    AcDbGripData *pGripData = new AcDbGripData();
    pGripData->setGripPoint(_basePoint);
    grips.append(pGripData);
 
    return Acad::eOk;
}
 
Acad::ErrorStatus AdskTree::subMoveGripPointsAt (
    const AcDbVoidPtrArray &gripAppData, 
    const AcGeVector3d &offset,
    const int bitflags) 
{
    assertWriteEnabled () ;
 
    _basePoint += offset;
 
    return Acad::eOk;
}
 
Acad::ErrorStatus AdskTree::subTransformBy(
                                    const AcGeMatrix3d& xform)
{
    assertWriteEnabled();
    _basePoint.transformBy(xform);
    return (AcDbEntity::subTransformBy(xform));
}
 
 
 
// acrxEntryPoint.cpp
// Usage 
 
#include "resource.h"
#include "AdskTree.h"
 
#include "stdafx.h"
#include "dbMultiModesGrip.h"
#include "TreeMultiModesGripPE.h"
 
static AdskTreeMultiModesGripPE *pMyMultiModeGrips = NULL;
 
#define szRDS _RXST("Adsk")
 
//----- ObjectARX EntryPoint
class CMultiModeGripSimpleSampleApp : public AcRxArxApp {
 
public:
    CMultiModeGripSimpleSampleApp () : AcRxArxApp () {}
 
    virtual AcRx::AppRetCode On_kInitAppMsg (void *pkt) {
        // TODO: Load dependencies here
 
        // You *must* call On_kInitAppMsg here
        AcRx::AppRetCode retCode 
                            =AcRxArxApp::On_kInitAppMsg(pkt) ;
 
        AdskTreeMultiModesGripPE::rxInit();
        AdskTree::rxInit();
        acrxBuildClassHierarchy();
 
        // TODO: Add your initialization code here
        if(pMyMultiModeGrips == NULL)
        {
            pMyMultiModeGrips = new AdskTreeMultiModesGripPE();
            AdskTree::desc()->addX(
                                AcDbMultiModesGripPE::desc(), 
                                pMyMultiModeGrips);
        }
 
        return (retCode) ;
    }
 
    virtual AcRx::AppRetCode On_kUnloadAppMsg (void *pkt) {
        // TODO: Add your code here
 
        // You *must* call On_kUnloadAppMsg here
        AcRx::AppRetCode retCode 
                        = AcRxArxApp::On_kUnloadAppMsg (pkt) ;
 
        // TODO: Unload dependencies here
        if(pMyMultiModeGrips != NULL)
        {
            delete pMyMultiModeGrips;
            pMyMultiModeGrips = NULL;
        }
        return (retCode) ;
    }
 
    virtual void RegisterServerComponents () {
    }
 
 
    // "Tree" command to create a tree
    static void AdskMultiModeGripSimpleSampleTREE(void)
    {
        ads_point pt;
        if (RTNORM != acedGetPoint(
                    NULL, L"\nSelect tree base point: ", pt))
            return;
 
        AcGePoint3d insertionPt = asPnt3d( pt );
 
        AdskTree *pTree = new AdskTree();
        pTree->setDatabaseDefaults();
        pTree->setBasePoint(insertionPt);
        PostToDb(pTree);
    }
 
    // Add the entity to DB
    static Acad::ErrorStatus PostToDb(AcDbEntity* pEnt)
    {
        AcDbDatabase *pDb 
            = acdbHostApplicationServices()->workingDatabase();
        AcDbObjectId objId;
 
        Acad::ErrorStatus      es;
        AcDbBlockTable*        pBlockTable;
        AcDbBlockTableRecord*  pSpaceRecord;
 
        pDb->getBlockTable(pBlockTable, AcDb::kForRead);
        pBlockTable->getAt( ACDB_MODEL_SPACE, 
                            pSpaceRecord, 
                            AcDb::kForWrite);
        es = pSpaceRecord->appendAcDbEntity(objId, pEnt);
        es = pEnt->close();
        es = pSpaceRecord->close();
        es = pBlockTable->close();
 
        return es;
    }
 
    // Command to update the graphics after the 
    // grip mode was changed. 
    // This will ensure a graphics is in sync with the
    // mode selected 
    static void AdskMultiModeGripSimpleSampleModeSwitchCmd(void)
    {
        AcDbObjectId entId 
            = AdskTreeMultiModesGripPE::getLastModifiedEntId(); 
 
        AcApDocument *pActiveDoc 
                        = acDocManager->mdiActiveDocument();
        AcDbDatabase *pDb = pActiveDoc->database();
 
        if(entId.isNull())
            return;
 
        AcDbEntity* pEnt = NULL;
        acdbOpenAcDbEntity(pEnt, entId, AcDb::kForWrite);
        pEnt->recordGraphicsModified();
        pEnt->close();
        acedUpdateDisplay();
    }
} ;
 
//-----------------------------------------------------------------------------
IMPLEMENT_ARX_ENTRYPOINT(CMultiModeGripSimpleSampleApp)
 
ACED_ARXCOMMAND_ENTRY_AUTO(CMultiModeGripSimpleSampleApp, 
                           AdskMultiModeGripSimpleSample, 
                           TREE, 
                           TREE, 
                           ACRX_CMD_TRANSPARENT, 
                           NULL)
ACED_ARXCOMMAND_ENTRY_AUTO(CMultiModeGripSimpleSampleApp, 
                           AdskMultiModeGripSimpleSample, 
                           ModeSwitchCmd, 
                           ModeSwitchCmd, 
                           ACRX_CMD_TRANSPARENT, 

Download MultiModeGrip_SimpleSample

Here is an image of the "tree" custom entity in the two modes :

Posted at 01:37 AM in 2012, 2013, 2014, AutoCAD, Balaji Ramamoorthy, ObjectARX | Permalink | Comments (0)

11/28/2013

Overruling grips for a Group

By Balaji Ramamoorthy

From the class hierarchy we realize that a Group is not derived from Entity class. It is a DBObject and resides in a dictionary. So, to overrule the grips of a Group, we need to overrule the grips of entities that belong to the group. When a group is selected in AutoCAD, it displays the grips of the entities that belong to the group or a single grip, depending on the value set for the "GroupDisplayMode" system variable. The overruling demonstrated in this sample code requires the "GroupDisplayMode" system variable to be set to "0". In that case, AutoCAD attempts to display the grips of the all entities that are part of the group and our overruling then takes effect.

Here is a sample code and a screenshot of the result

static GripPointOverrule m_gripOverrule 
                                    = new GripPointOverrule();
static Overrule[] m_overrules = new Overrule[]
{
    m_gripOverrule,
};
static bool m_overruleAdded = false;
 
[CommandMethod("GGO")]
static public void GroupGripOverrule()
{
    if (! m_overruleAdded)
    {
        m_gripOverrule = new GripPointOverrule();
        Overrule.AddOverrule
        (
            RXObject.GetClass(
            typeof(Autodesk.AutoCAD.DatabaseServices.Entity)), 
            m_gripOverrule, 
            true
        );
        m_gripOverrule.SetCustomFilter(); 
        Overrule.Overruling = true;
 
        m_overruleAdded = true;
    }
    else
    {
        Overrule.RemoveOverrule
        (
            RXObject.GetClass(
            typeof(Autodesk.AutoCAD.DatabaseServices.Entity)), 
            m_gripOverrule
        );
        Overrule.Overruling = false;
        m_gripOverrule.Dispose();
        m_gripOverrule = null;
 
        m_overruleAdded = false;
    }
 
    Application.DocumentManager.MdiActiveDocument.Editor.Regen();
}
 
class GripPointOverrule : GripOverrule
{
    internal GripPointOverrule() { }
 
    internal class MyGrip : GripData
    {
        public MyGrip() { }
 
        public override bool ViewportDraw
            (
                ViewportDraw vd,
                ObjectId entityId,
                GripData.DrawType type,
                Point3d? imageGripPoint,
                int gripSize
            )
        {
            Point2d unit 
            = vd.Viewport.GetNumPixelsInUnitSquare(GripPoint);
            vd.SubEntityTraits.Color = 2;
 
            vd.SubEntityTraits.FillType = FillType.FillAlways; 
            double radius = gripSize / unit.X;
            vd.Geometry.Circle
                (GripPoint, radius, vd.Viewport.ViewDirection);
 
            return true;
        }
    }
 
    List<GripData> m_grips = new List<GripData>();
 
    public override void GetGripPoints
        (
            Entity entity, 
            GripDataCollection grips, 
            double curViewUnitSize, 
            int gripSize, 
            Vector3d curViewDir, 
            GetGripPointsFlags bitFlags
        )
    {
        // We do not want the default entity grips
        //base.GetGripPoints(entity, grips, curViewUnitSize, gripSize, curViewDir, bitFlags);
 
        // Find the extents of the entities in the group
        Extents3d groupExts = new Extents3d();
        using (Transaction tr 
        = entity.Database.TransactionManager.StartTransaction())
        {
            ObjectIdCollection ids = entity.GetPersistentReactorIds();
            foreach (ObjectId id in ids)
            {
                DBObject obj = tr.GetObject(id, OpenMode.ForRead);
                if (obj is Group)
                {
                    Group group = obj as Group;
                    ObjectId[] entIds = group.GetAllEntityIds();
                    foreach (ObjectId entId in entIds)
                    {
                        Entity cogroupEnt = 
                        tr.GetObject
                        (
                            entId, 
                            OpenMode.ForRead
                        ) as Entity;
 
                        if (cogroupEnt != null)
                        {
                            Extents3d exts 
                                = cogroupEnt.GeometricExtents;
                            groupExts.AddExtents(exts);
                        }
                    }
                }
            }
            tr.Commit();
        }
 
        // Add a single grip at the min point of the 
        // group extents
        MyGrip myGripData = new MyGrip();
        myGripData.GripPoint = groupExts.MinPoint;
        m_grips.Add(myGripData);
        grips.Add(myGripData);
    }
 
    public override void MoveGripPointsAt
        (
            Entity entity, 
            GripDataCollection grips, 
            Vector3d offset, 
            MoveGripPointsFlags bitFlags
        )
    {
        foreach(GripData grip in grips)
        {
            MyGrip myGrip = grip as MyGrip;
            if (myGrip != null)
            {
                entity.TransformBy(
                                Matrix3d.Displacement(offset));
            }
            else
                base.MoveGripPointsAt(
                            entity, grips, offset, bitFlags);
        }
    }
 
    // Overrule only entities that belong to a group
    public override bool IsApplicable(RXObject overruledSubject)
    {
        bool isApplicable = false;
        try
        {
            Entity ent = overruledSubject as Entity;
            if (ent != null && ent.Database != null)
            {
                // Check if the entity is part of a group
                using (Transaction tr 
                    = ent.Database.TransactionManager.StartTransaction())
                {
                    ObjectIdCollection ids 
                                = ent.GetPersistentReactorIds();
                    foreach (ObjectId id in ids)
                    {
                        DBObject obj 
                        = tr.GetObject(id, OpenMode.ForRead);
                        if (obj is Group)
                        {
                            Group group = obj as Group;
                            if (group != null)
                            {
                                // If the entity belongs to 
                                // a group, we will overrule it 
                                isApplicable = true;
                            }
                        }
                    }
                    tr.Commit();
                }
            }
        }
        catch (System.Exception ex)
        {
            Application.DocumentManager.MdiActiveDocument
                            .Editor.WriteMessage(ex.Message);
        }
        return isApplicable;
    }
}

Posted at 10:26 PM in .NET, 2012, 2014, AutoCAD, Balaji Ramamoorthy | Permalink | Comments (9)

11/27/2013

Inserting RasterImage using image buffer

By Balaji Ramamoorthy

The AcDbRasterImageDef::setImage can be used, if you do not want to include the image file path while inserting a raster image. This can be considered another approach to accomplish what is explained in this blog post. The AcDbRasterImageDef::setImage method requires a pointer to an ATIL image. In this sample code, the image buffer is read from the image and is used to create an ATIL image. The ATIL image pointer is used with the AcDbRasterImageDef::setImage to create a raster image definition. To build this sample code, you will need the include and library files from the ObjectARX SDK folder under "\utils\Atil".

static void AdskInsertImage(void)
{
    // Image path to use for the RasterImageDef
    AcString imagePath(ACRX_T("C:\\Temp\\Test.png"));
 
    // Load the image to get access to its image buffer
    AcTcImage tc;
    tc.Load(imagePath);
 
    HBITMAP bmp=0;
    tc.GetHBITMAP(RGB(0xff,0xff,0xff),bmp);
 
    if (bmp == NULL)
        return;
 
    BITMAP _bmp={0};
    GetObject(bmp,sizeof BITMAP,&_bmp);
 
    HDC hdcScr=GetDC(NULL);
    HDC    hdcMem=CreateCompatibleDC(hdcScr);
    SelectObject(hdcMem,bmp);
 
    // Create an Atil::Image.
    // The AcDbRasterImageDef::setImage requires it
    Atil::ImagePixel initialImage;
    initialImage.setToZero();
    initialImage.type = Atil::DataModelAttributes::kRgba;
    initialImage.value.rgba = 0xff000000;
 
    Atil::Size size(_bmp.bmWidth, _bmp.bmHeight);
    const Atil::RgbModel *pDm = new Atil::RgbModel(
        Atil::RgbModelAttributes::k4Channels, 
        Atil::DataModelAttributes::kBlueGreenRedAlpha);
 
    Atil::Image *pAtilImage = new Atil::Image(
                                     size, pDm, initialImage);
 
    // Write the image data on to the Atil image 
    // using an Image Context
    Atil::Offset upperLeft(0,0);
    Atil::ImageContext *pImgContext 
        = pAtilImage->createContext(
                                    Atil::ImageContext::kWrite, 
                                    size, 
                                    upperLeft
                                    );
    if (pImgContext != NULL)
    {
        for (int xf=0;xf<_bmp.bmWidth;xf++)
        {
            for (int yf=0;yf<_bmp.bmHeight;yf++)
            {
                BYTE alpha=0x0;
 
                COLORREF pix=GetPixel(hdcMem,xf,yf);
 
                BYTE rr = (pix&0xff);
                BYTE gg = (pix>>8)&0xff;
                BYTE bb = (pix>>16)&0xff;
 
                // Alpha channel to account for transparency
                if ((rr!=0xff) || (gg!=0xff) || (bb!=0xff))
                    alpha=0xff;
 
                Atil::RgbColor p;
                p.set(rr, gg, bb, alpha);
                pImgContext->put32(xf, yf, p);
            }
        }
 
    }
    pImgContext->flush();
    delete pImgContext;
 
    bool isImageValid = pAtilImage->isValid();
    ASSERT(isImageValid);
 
    // Create a RasterImageDef and set the image
    // from the Atil image
    AcDbRasterImageDef *pImageDef = new AcDbRasterImageDef();
    Acad::ErrorStatus es = pImageDef->setImage(
                                            pAtilImage, NULL);
 
    // Insert the RasterImageDef and create a RasterImage
    // using it
    es = InsertImageInDwg(pImageDef);
    if(es != Acad::eOk)
    {
        delete pImageDef;
        return;
    }
 
    // Cleanup
    DeleteDC(hdcMem);
    ReleaseDC(NULL,hdcScr);
 
    DeleteObject( bmp);
}
 
static Acad::ErrorStatus InsertImageInDwg(
                                AcDbRasterImageDef *pImageDef)
{
    Acad::ErrorStatus es;
    if(! pImageDef->isLoaded())
    {
        es = pImageDef->load();
        if(es != Acad::eOk)
            return es;
    }
 
    AcApDocument *pActiveDoc = acDocManager->mdiActiveDocument();
    AcDbDatabase *pDB = pActiveDoc->database();
 
    // Get the image dictionary
    // Create it if not available already
    AcDbObjectId dictID 
                    = AcDbRasterImageDef::imageDictionary(pDB);
    if(dictID == AcDbObjectId::kNull)
    {
        es = AcDbRasterImageDef::createImageDictionary(
                                                  pDB, dictID);
        if(es != Acad::eOk)
            return es;
    }
 
    AcDbDictionary* pDict;
    es = acdbOpenObject(pDict, dictID, AcDb::kForWrite);
    if(es != Acad::eOk)
            return es;
 
    ACHAR *DICT_NAME = ACRX_T("ISM_RASTER_IMAGE_DICT_VIEW");
    BOOL bExist = pDict->has(DICT_NAME);
    AcDbObjectId objID = AcDbObjectId::kNull;
    if (!bExist)
    {
        es = pDict->setAt(DICT_NAME, pImageDef, objID);
        if(es != Acad::eOk)
            return es;
    }
    else
    {
        pDict->getAt(DICT_NAME, 
                    (AcDbObject*&)pImageDef, 
                    AcDb::kForWrite); 
        objID = pImageDef->objectId();
    }
 
    // close Dictionary and Definition.
    pDict->close();
    pImageDef->close();
 
    // Create a raster image using the RasterImage Def
    AcDbRasterImage* pImage = new AcDbRasterImage;
    es = pImage->setImageDefId(objID);
    if (es != Acad::eOk)
    {
        delete pImage;
        return es;
    }
 
    // Add the raster image to the model space
    AcDbBlockTable* pBlockTable;
    AcDbBlockTableRecord* pBTRecord;
    es = acdbCurDwg()->getBlockTable(pBlockTable, 
                                     AcDb::kForRead);
    assert(es == Acad::eOk);
    es = pBlockTable->getAt(ACDB_MODEL_SPACE, 
                            pBTRecord, 
                            AcDb::kForWrite);
    assert(es == Acad::eOk);
 
    es = pBTRecord->appendAcDbEntity(pImage);
    assert(es == Acad::eOk);
 
    pBTRecord->close();
    pBlockTable->close();
 
    AcDbObjectId entID = pImage->objectId();
 
    // Set the transparency options 
    pImage->setDisplayOpt(    AcDbRasterImage::kTransparent, 
                            Adesk::kTrue);
 
    pImage->setImageTransparency(true);
    pImage->setDisplayOpt(AcDbRasterImage::kShow, Adesk::kTrue);
 
    AcDbObjectPointer<AcDbRasterImageDefReactor> 
                                        rasterImageDefReactor;
    rasterImageDefReactor.create();
 
    es = rasterImageDefReactor->setOwnerId(pImage->objectId());
    if (es == Acad::eOk)
    {
        AcDbObjectId defReactorId;
        es = curDoc()->database()->addAcDbObject(
                            defReactorId, 
                            rasterImageDefReactor.object());
 
        if (es == Acad::eOk)
        {
            pImage->setReactorId(defReactorId);
            AcDbObjectPointer<AcDbRasterImageDef> rasterImagedef
                      (pImage->imageDefId(), AcDb::kForWrite);
            if (rasterImagedef.openStatus() == Acad::eOk)
            {
                rasterImagedef->addPersistentReactor
                                               (defReactorId);
            }
        }
    }
 
    pImageDef->close();
    pImage->close();
}

Posted at 10:52 PM in 2012, 2013, 2014, AutoCAD, Balaji Ramamoorthy, ObjectARX | Permalink | Comments (14)

11/09/2013

DrawableOverrule to highlight entities in nested block references and Xrefs

By Balaji Ramamoorthy

Some time back, I had posted this blog post to change the color of entities using DrawableOverrule. But it did not handle entities in block references well. Here is a completely rewritten code snippet that handles entities in block references, nested block references and Xrefs.

public class MyDrawOverrule : DrawableOverrule
{
    private bool mRegistered = false;
 
    private static bool mOldOverruleValue;
    public List<ObjectId> _containerIds = new List<ObjectId>();
    public ObjectId _selectedId = ObjectId.Null;
 
    public List<ObjectId> ContainerIds
    {
        get { return _containerIds; }
        set { _containerIds = value; }
    }
 
    public ObjectId SelectedId
    {
        get { return _selectedId; }
        set { _selectedId = value; }
    }
 
    public void Highlight()
    {
        if (!mRegistered)
        {
            Overrule.AddOverrule(RXObject.GetClass
                                (typeof(Entity)), this, false);
            SetCustomFilter();
            mOldOverruleValue = Overrule.Overruling;
            mRegistered = true;
        }
        Overrule.Overruling = true;
 
        Application.DocumentManager.MdiActiveDocument
                                              .Editor.Regen();
    }
 
    public override bool WorldDraw(    Drawable drawable, 
                                    WorldDraw wd)
    {
        bool status = false;
 
        Entity ent = drawable as Entity;
 
        if(ContainerIds.Count == 0)
        {
            if(ent.ObjectId.Equals(_selectedId))
            { 
                // Not a nested entity, but selected 
                // for overruling
 
                short oldColor = wd.SubEntityTraits.Color;
                wd.SubEntityTraits.Color = 2;
 
                status = base.WorldDraw(drawable, wd);
 
                wd.SubEntityTraits.Color = oldColor;
            }
            else
                status = base.WorldDraw(drawable, wd);
        }
        else if (ContainerIds.Contains(ent.ObjectId))
        { // Selected a nested entity
 
            status = base.WorldDraw(drawable, wd);
 
            ColorizeNested(ent, Matrix3d.Identity, wd);
        }
        else
        {
            status = base.WorldDraw(drawable, wd);
        }
 
        return status;
    }
 
    public bool ColorizeNested(    Entity ent, 
                                Matrix3d transform, 
                                WorldDraw wd)
    {
        bool status = false;
        if (ent is BlockReference 
            && ContainerIds.Contains(ent.ObjectId))
        {
            BlockReference br = ent as BlockReference;
            transform 
                = transform.PreMultiplyBy(br.BlockTransform);
 
            if (br.Database != null)
            {
                using (Transaction tr 
                    = br.Database.TransactionManager
                                .StartOpenCloseTransaction())
                {
                    BlockTableRecord btr 
                        = tr.GetObject(    br.BlockTableRecord, 
                                        OpenMode.ForRead
                                      ) as BlockTableRecord;
                    foreach (ObjectId id in btr)
                    {
                        Entity btrEnt = tr.GetObject
                            (
                                id, 
                                OpenMode.ForRead
                            ) as Entity;
                        if (btrEnt is BlockReference)
                        {
                            status = ColorizeNested(
                                    btrEnt, transform, wd);
                        }
                        else
                        {
                            if (btrEnt.ObjectId.Equals(
                                                _selectedId))
                            {
                                using (Entity entClone 
                                    = btrEnt.Clone() as Entity)
                                {
                                    entClone.TransformBy
                                                  (transform);
                                    entClone.ColorIndex = 2;
                                    status 
                                    = wd.Geometry.Draw(entClone);
                                }
                            }
                        }
                    }
                    tr.Commit();
                }
            }
        }
        return status;
    }
 
    public override bool IsApplicable(RXObject overruledSubject)
    {
        bool isApplicable = false;
        Entity ent = overruledSubject as Entity;
        if (ent != null)
        {
            if (ContainerIds.Count == 0)
            {
                if(ent.ObjectId.Equals(SelectedId))
                {
                    isApplicable = true;
                }
            }
            else if (ent.ObjectId.Equals(ContainerIds[0]))
            {
                isApplicable = true;
            }
        }
        return isApplicable;
    }
}
 
public class Commands : IExtensionApplication
{
    private static MyDrawOverrule _myDrawOverrule 
                                       = new MyDrawOverrule();
 
    [CommandMethod("HighlightEnt")]
    static public void HighlightEnt()
    {
        Document doc 
              = Application.DocumentManager.MdiActiveDocument;
        Database db = doc.Database;
        Editor ed = doc.Editor;
 
        _myDrawOverrule.SelectedId = ObjectId.Null;
        _myDrawOverrule.ContainerIds.Clear();
        ObjectId selId = ObjectId.Null;
 
        PromptNestedEntityOptions pneo 
            = new PromptNestedEntityOptions(
                           "\nSelect entity to highlight : ");
        PromptNestedEntityResult pner = ed.GetNestedEntity(pneo);
        if (pner.Status == PromptStatus.OK)
        {
            selId = pner.ObjectId;
            _myDrawOverrule.SelectedId = selId;
 
            List<ObjectId> objIds 
                   = new List<ObjectId>(pner.GetContainers());
            if (objIds.Count > 0)
            {
                objIds.Reverse();
                foreach (ObjectId id in objIds)
                    _myDrawOverrule.ContainerIds.Add(id);
            }
 
            _myDrawOverrule.Highlight();
        }
    }
 
    void IExtensionApplication.Initialize(){}
 
    void IExtensionApplication.Terminate(){}
}

Posted at 08:10 AM in .NET, 2011, 2012, 2013, 2014, AutoCAD, Balaji Ramamoorthy | Permalink | Comments (3)

11/01/2013

Importing ToolPalette/ToolPaletteGroup from XTP/XPG files

By Balaji Ramamoorthy

Importing ToolPalette and ToolPaletteGroup from xtp and xtg files require user interaction in AutoCAD. Here is a sample ObjectARX code to automate that. Some portion of this code retrieves information from the xtp / xtg files by accessing them as plain XML document. This code worked ok for simple xtp and xtg files that I used during my tests. It might however still need more error handling code which Iam sure you can include based on your needs.

CAcTcUiManager *pTcUiManager = AcTcUiGetManager(); 
CAcTcUiToolPaletteSet *pTpset = AcTcUiGetToolPaletteWindow(); 
 
// List of xtp files to import
AcArray<AcString> xtpFiles;
xtpFiles.append(ACRX_T("C:\\Temp\\MyTP.xtp"));
 
// List of xpg files to import
AcArray<AcString> xpgFiles;
xpgFiles.append(ACRX_T("C:\\Temp\\MyTPGroup.xpg"));
 
// Import the ToolPalette from the xtp file
// By default the toolpalette is added to the "AllPalettesGroup"
// After importing from the xtp file, get its name
// We will need the names to move the toolpalette to the 
// toolpalette groups that will be imported from xpg file.
AcArray<AcString> toolPaletteNames;
for(int xtpFileIndex =0; 
        xtpFileIndex < xtpFiles.length(); xtpFileIndex++)
{
    // Get the xtp file path
    AcString xtpFilePath = xtpFiles.at(xtpFileIndex);
 
    if(pTcUiManager->Import(xtpFilePath))
    {
        acutPrintf(ACRX_T("\nImported %s"), xtpFilePath);
    }
 
    // The ToolPalette was imported, but we need to find its
    // name so we can relocate it to our ToolPaletteGroup
    // Find the name of the ToolPalette that was now imported 
    // from the XTP file.
    CComPtr<IXMLDOMDocument> pXTPDoc;
    HRESULT hr = pXTPDoc.CoCreateInstance(CLSID_DOMDocument,
                                NULL, CLSCTX_INPROC_SERVER);
    if (FAILED(hr)) 
        return;
 
    CComVariant xmlSource = xtpFilePath.constPtr();
    VARIANT_BOOL varSuccess = VARIANT_FALSE;
    hr = pXTPDoc->load(xmlSource, &varSuccess);
    if (FAILED(hr) || ! varSuccess)
        return;
 
    // Find the "<Palette></Palette> nodes from the xml
    CComPtr<IXMLDOMNodeList> pTPNodeList = NULL;
    hr = pXTPDoc->getElementsByTagName(ACRX_T("Palette"), 
                                                &pTPNodeList);
    if (FAILED(hr))
        return;
 
    long tpCount = 0;
    hr = pTPNodeList->get_length(&tpCount);
    if(FAILED(hr))
        return;
 
    pTPNodeList->reset();
    for(int ii = 0; ii < tpCount; ii++)
    {
        CComPtr<IXMLDOMNode> pTPNode = NULL;
        hr = pTPNodeList->get_item(ii, &pTPNode);
        if(FAILED(hr))
            return;
 
        if(pTPNode)
        {
            CComPtr<IXMLDOMNode> pTPParentNode = NULL;
            hr = pTPNode->get_parentNode(&pTPParentNode);
            if(SUCCEEDED(hr))
            {
                // Check the node's parent name
                // to be sure we can use it to find the 
                // ToolPalette name
                CComBSTR bstrParentNodeName;
                hr = pTPParentNode->get_nodeName
                                        (&bstrParentNodeName);
                if(SUCCEEDED(hr) 
                && bstrParentNodeName == ACRX_T("ToolSource"))
                {
                    BSTR bstrTPName = NULL;
                    hr = pTPNode->get_text(&bstrTPName);
                    if(SUCCEEDED(hr))
                    {
                        AcString toolPaletteName(bstrTPName);
                        toolPaletteNames.append(toolPaletteName);
                        ::SysFreeString(bstrTPName);
                    }
                }
            }
        }
    }
}
 
// Import the ToolPaletteGroup from the xpg file
// By default the toolpalettegroup is empty
// After importing from the xpg file, 
// We will move the toolpalettes that were imported to the 
// toolpalette group that is imported from xpg file.
for(int xpgFileIndex =0; 
            xpgFileIndex < xpgFiles.length(); xpgFileIndex++)
{
    AcString xpgFilePath = xpgFiles.at(xpgFileIndex);
 
    // Create an XML Doc instance
    CComPtr<IXMLDOMDocument> pXPGDoc;
    HRESULT hr = pXPGDoc.CoCreateInstance(CLSID_DOMDocument, 
                                 NULL, CLSCTX_INPROC_SERVER);
    if (FAILED(hr)) 
        return;
 
    // Load the XPG file as an XML doc
    CComVariant xmlSource = xpgFilePath.constPtr();
    VARIANT_BOOL bSuccess = VARIANT_FALSE;
    hr = pXPGDoc->load(xmlSource, &bSuccess);
    if (FAILED(hr) || ! bSuccess)
        return;
 
    // Get the XML nodes from the XPG file that corresponds to
    // a ToolPalette Group
    CComPtr<IXMLDOMNodeList> pTPGNodeList = NULL;
    hr = pXPGDoc->getElementsByTagName(
                                  ACRX_T("ToolPaletteGroup"),
                                  &pTPGNodeList);
    if (FAILED(hr))
        return;
 
    // Find the number of ToolPalette group nodes 
    // from the XPG file
    long tpgCount = 0;
    hr = pTPGNodeList->get_length(&tpgCount);
    if(FAILED(hr))
        return;
 
    pTPGNodeList->reset();
    for(int tpgIndex = 0; tpgIndex < tpgCount; tpgIndex++)
    {
        // Get a single XML node that corresponds 
        // to a ToolPalette Group
        CComPtr<IXMLDOMNode> pTPGNode = NULL;
        hr = pTPGNodeList->get_item(tpgIndex, &pTPGNode);
        if(FAILED(hr) || pTPGNode == NULL)
            return;
 
        // Create a new ToolPalette group and 
        CAcTcUiToolPaletteGroup *pRootTpgroup 
                        = pTpset->GetToolPaletteGroup(FALSE);
        CAcTcUiToolPaletteGroup * pMyToolPaletteGroup = NULL;
        pRootTpgroup->Clone(pMyToolPaletteGroup);
        pMyToolPaletteGroup->Reset();
 
        // Import the ToolPalette group settings 
        // from the XPG file
        if(pMyToolPaletteGroup->Load(pTPGNode))
        {
            pRootTpgroup->AddItem(pMyToolPaletteGroup);
            pTpset->SetActivePaletteGroup(pMyToolPaletteGroup);
            acutPrintf(ACRX_T("\nImported %s"), xpgFilePath);
        }
 
        // Add the custom ToolPalettes 
        // to the custom ToolPalette group.
        CAcTcUiToolPaletteGroup *pAllPalettesGroup 
                            = pTpset->GetAllPalettesGroup();
        for(int ii =0; ii < toolPaletteNames.length(); ii++)
        {
            AcString toolPaletteName = toolPaletteNames.at(ii);
            CAcTcUiToolPalette *pMyCustomPalette 
                = pAllPalettesGroup->FindPalette(
                                    toolPaletteName, NULL);
            if(pMyCustomPalette != NULL)
            {
                // Add the custom ToolPalette to the 
                // custom ToolPalette group.
                pMyToolPaletteGroup->AddItem(pMyCustomPalette);
            }
        }
    }
}

Posted at 06:40 AM in 2011, 2012, 2013, 2014, AutoCAD, Balaji Ramamoorthy, ObjectARX | Permalink | Comments (10)

10/22/2013

Accessing extension dictionary of an overruled entity while dragging

By Balaji Ramamoorthy

When an entity that is being overruled is dragged, AutoCAD only creates a shallow copy of it. For this reason, the extension dictionary of the cloned entity is inaccessible from within the overrule class. One way to ensure that we get access to the extension dictionary is to drag the original entity and not its clone using the "TransformOverrule::CloneMeForDragging" and return false. Using this technique is not suggested as it is only meant for use with complex entities that can cause performance issues when cloned for dragging purposes.

The workaround is to override the "TransformOverrule::CloneMeForDragging" and continue to return "true" and use the original entity which is a parameter to this method to access the extension dictionary.

Here is a sample code to demonstrate this.

using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.GraphicsInterface;
 
public class HelperClass
{
    const String _extDictName = "myExtDict";
    const String _XRecName = "myXRec";
    List<TypedValue> _data = new List<TypedValue>();
 
    public List<TypedValue> Data
    {
        get { return _data; }
    }
 
    private static HelperClass _instance;
    public String DictionaryName
    {
        get { return _extDictName; }
    }
 
    public String XRecordName
    {
        get { return _XRecName; }
    }
 
    protected HelperClass()
    {
    }
 
    public static HelperClass GetSingleton
    {
        get
        {
            if (_instance == null)
            {
                _instance = new HelperClass();
            }
            return _instance;
        }
    }
 
    public void CaptureXRecordData(DBObject obj)
    {
        Xrecord xRec = null;
        ObjectId id = obj.ExtensionDictionary;
 
        _data.Clear();
        if (! id.IsValid)
            return;
 
        Database db 
        = Application.DocumentManager.MdiActiveDocument.Database;
        using (Transaction tr 
            = db.TransactionManager.StartOpenCloseTransaction())
        {
            DBDictionary extDict = tr.GetObject(
                                    id, 
                                    OpenMode.ForRead, 
                                    false) as DBDictionary;
            if (extDict.Contains(DictionaryName))
            {
                ObjectId dictId = extDict.GetAt(DictionaryName);
                DBDictionary myDict = tr.GetObject(
                                    dictId, 
                                    OpenMode.ForRead, 
                                    false) as DBDictionary;
                xRec = tr.GetObject(
                                    myDict.GetAt(XRecordName), 
                                    OpenMode.ForRead, 
                                    false) as Xrecord;
 
                if (xRec != null)
                {
                    ResultBuffer rb = xRec.Data;
                    if (rb != null)
                    {
                        TypedValue[] tvArray = rb.AsArray();
                        foreach (TypedValue tv in tvArray)
                        {
                            _data.Add(
                                    new TypedValue(
                                                   tv.TypeCode, 
                                                   tv.Value
                                                  )
                                     );
                        }
                        rb.Dispose();
                    }
                }
            }
            tr.Commit();
        }
    }
}
 
public class MyCommands
{
    static CMyDrawableOverrule lineOverrule = null;
    static CMyTransformeOverrule transformOverrule = null;
 
    [CommandMethod("OT")]
    public void OverruleTest()
    {
        Editor ed 
        = Application.DocumentManager.MdiActiveDocument.Editor;
        PromptEntityResult per;
        per = ed.GetEntity("Pick a line to overrule");
        if(per.Status != PromptStatus.OK)
            return;
 
        Database db = HostApplicationServices.WorkingDatabase;
        using (Transaction tr 
                    = db.TransactionManager.StartTransaction())
        {
            Entity ent = (Entity)tr.GetObject(
                            per.ObjectId, OpenMode.ForWrite);
 
            RegAppTable regTable = (RegAppTable)tr.GetObject(
                    db.RegAppTableId, OpenMode.ForRead, false);
 
            if (!regTable.Has("TEST"))
            {
                regTable.UpgradeOpen();
                RegAppTableRecord app = new RegAppTableRecord();
                app.Name = "TEST";
                regTable.Add(app);
                tr.AddNewlyCreatedDBObject(app, true);
            }
            ent.XData = new ResultBuffer(
                                new TypedValue(1001, "TEST"), 
                                new TypedValue(1070, 100));
 
            string extDictName = "myExtDict";
            string xRecName = "myXRec";
 
            if (ent.ExtensionDictionary == ObjectId.Null)
            {
                ent.CreateExtensionDictionary();
            }
 
            DBDictionary xDict = tr.GetObject(
                            ent.ExtensionDictionary, 
                            OpenMode.ForWrite) as DBDictionary;
 
            xDict.TreatElementsAsHard = true;
 
            if (!xDict.Contains(extDictName))
            {
                DBDictionary newDict = new DBDictionary();
                newDict.TreatElementsAsHard = true;
 
                xDict.SetAt(extDictName, newDict);
                tr.AddNewlyCreatedDBObject(newDict, true);
 
                Xrecord xRec = new Xrecord();
 
                xRec.Data = new ResultBuffer(
                            new TypedValue((int)DxfCode.Text, 
                                            "Autodesk"));
 
                newDict.SetAt(xRecName, xRec);
                tr.AddNewlyCreatedDBObject(xRec, true);
            }
            tr.Commit();
        }
 
        if (lineOverrule == null)
        {
            transformOverrule = new CMyTransformeOverrule();
            Overrule.AddOverrule(
                RXObject.GetClass(typeof(Line)), 
                transformOverrule, 
                true);
 
            transformOverrule.SetXDataFilter("TEST");
 
            lineOverrule = new CMyDrawableOverrule();
            Overrule.AddOverrule(
                RXObject.GetClass(typeof(Line)), 
                lineOverrule, 
                true);
 
            lineOverrule.SetXDataFilter("TEST");
 
            Overrule.Overruling = true;
        }
 
        Application.DocumentManager.MdiActiveDocument.Editor.Regen();
    }
}
 
public class CMyDrawableOverrule : DrawableOverrule
{
    [DllImport("acdb19.dll", 
                CharSet = CharSet.Unicode, 
                CallingConvention = CallingConvention.Cdecl, 
                EntryPoint = "?fromAcDbTextStyle@@YA?AW4ErrorStatus@Acad@@AEAVAcGiTextStyle@@AEBVAcDbObjectId@@@Z")]
 
    private static extern Autodesk.AutoCAD.Runtime.ErrorStatus 
        fromAcDbTextStyle(System.IntPtr style, ref ObjectId id);
 
    public override bool WorldDraw(Drawable drawable, WorldDraw wd)
    {
        base.WorldDraw(drawable, wd);
 
        Line line = drawable as Line;
        if (line == null)
            return true;
 
        using (LineSegment3d seg = new LineSegment3d(
                    line.StartPoint, line.EndPoint))
        {
            if (wd.IsDragging)
            {
                wd.SubEntityTraits.Color = 1;
 
                // Retrieve the extension dictionary 
                // values retrieved using helper class
                List<TypedValue> tvList 
                       = HelperClass.GetSingleton.Data;
 
                foreach (TypedValue tv in tvList)
                {
                    ObjectId textStyleId = 
                    Application.DocumentManager.MdiActiveDocument.Database.Textstyle;
 
                    Autodesk.AutoCAD.GraphicsInterface.TextStyle iStyle 
                    = new Autodesk.AutoCAD.GraphicsInterface.TextStyle();
 
                    if (fromAcDbTextStyle
                        (
                            iStyle.UnmanagedObject, 
                            ref textStyleId
                        ) == Autodesk.AutoCAD.Runtime.ErrorStatus.OK)
                    {
                        wd.Geometry.Text(
                                        seg.MidPoint, 
                                        line.Normal, 
                                        Vector3d.XAxis, 
                                        tv.Value.ToString(), 
                                        true, iStyle);
                    }
                }
            }
            else
                wd.SubEntityTraits.Color = 2;
 
            wd.Geometry.Circle(seg.MidPoint, 
                               seg.Length * 0.25, 
                               line.Normal);
        }
        return true;
    }
}
 
public class CMyTransformeOverrule : TransformOverrule
{
    public override bool CloneMeForDragging(Entity entity)
    {
        // Retrieve the extension dictionary from the original 
        // entity. While dragging, the clone created is a 
        //shallow clone and the extension dictionary isnt accessible
        HelperClass.GetSingleton.CaptureXRecordData(entity);
 
        // Permit cloning while dragging
        return true;
    }
}

Here is a screenshot that displays the content of the extension dictionary while the entity is being dragged

Posted at 03:52 AM in .NET, 2011, 2012, 2013, 2014, AutoCAD, Balaji Ramamoorthy | Permalink | Comments (3)

10/17/2013

Keeping attributes horizontal while rotating a block using Jig

By Balaji Ramamoorthy

Here is a sample code to specify the rotation of a block reference using a Jig while retaining the attribute rotation as demonstrated in this video.

class BlockJigCmds
{
    [CommandMethod("BJig")]
    public static void BJig()
    {
        Editor ed 
        = Application.DocumentManager.MdiActiveDocument.Editor;
 
        PromptEntityOptions peo 
        = new PromptEntityOptions("\nSelect a block reference: ");
 
        peo.SetRejectMessage("\nMust be a block reference...");
        peo.AddAllowedClass(typeof(BlockReference), true);
 
        PromptEntityResult per = ed.GetEntity(peo);
        if (per.Status != PromptStatus.OK)
            return;
 
        ObjectId brefId = per.ObjectId;
 
        BRotateJig bjig = new BRotateJig(brefId);
        if (bjig.DoIt())
        {
            // Jigging complete. 
            // Make changes to the BlockReference based on the 
            // final rotation value.
            Database db = HostApplicationServices.WorkingDatabase;
            using (Transaction tr 
                    = db.TransactionManager.StartTransaction())
            {
                BlockReference bref = tr.GetObject(
                   brefId, OpenMode.ForWrite) as BlockReference;
 
                // Update the final block reference rotation
                bref.Rotation = bjig._brefAngle;
 
                // Update the final positions of the attribute references
                foreach (ObjectId id in bref.AttributeCollection)
                {
                    AttributeReference attref = tr.GetObject
                    (id, OpenMode.ForRead) as AttributeReference;
 
                    if (attref == null 
                || bjig._attPos.ContainsKey(attref.Tag) == false)
                        continue;
 
                    attref.UpgradeOpen();
                    attref.Position = bjig._attPos[attref.Tag];
                }
                tr.Commit();
            }
        }
    }
}
 
public class BRotateJig : DrawJig
{
    public Point3d _insPoint;
    public double _brefAngle = 0.0;
    private ObjectId _brefId = ObjectId.Null;
    private ObjectId _btrId = ObjectId.Null;
    private Extents3d _attExts = new Extents3d();
    private Dictionary<String, Vector3d> _attDisps;
    public Dictionary<String, Point3d> _attPos; 
 
    public BRotateJig(ObjectId brefId)
    {
        // Id of the block reference that we will jig 
        _brefId = brefId;
 
        Database db = HostApplicationServices.WorkingDatabase;
        using (Transaction tr = db.TransactionManager.StartTransaction())
        {
            BlockReference bref = tr.GetObject(
                brefId, OpenMode.ForWrite) as BlockReference;
 
            _btrId = bref.BlockTableRecord;
            _insPoint = bref.Position;
            _brefAngle = bref.Rotation;
 
            // We want to determine the extents of the 
            // attributes without considering the rotation 
            // that the block reference might already have.
            bref.Rotation = 0.0;
 
            // Determines the overall extents of the attribute 
            // references in the block
            BlockTableRecord btr = tr.GetObject(
                _btrId, OpenMode.ForRead) as BlockTableRecord;
            foreach (ObjectId id in btr)
            {
                DBObject obj = id.GetObject(OpenMode.ForRead);
                AttributeDefinition attDef 
                                = obj as AttributeDefinition;
 
                if ((attDef != null) && (!attDef.Constant))
                {
                    using (AttributeReference attRef 
                                    = new AttributeReference())
                    {
                        attRef.SetAttributeFromBlock(
                                attDef, bref.BlockTransform);
 
                        Extents3d exts = attRef.GeometricExtents;
                        _attExts.AddExtents(exts);
                    }
                }
            }
 
            // Stores the displacement of each attribute 
            //reference with mid point as the reference
            // This is needed to keep the attribute references 
            // straight after the block reference is rotated.
            Point3d midPt = _attExts.MinPoint + 
                (_attExts.MaxPoint - _attExts.MinPoint) * 0.5;
 
            _attDisps = new Dictionary<string, Vector3d>();
            foreach (ObjectId id in btr)
            {
                DBObject obj = id.GetObject(OpenMode.ForRead);
                AttributeDefinition attDef 
                                = obj as AttributeDefinition;
 
                if ((attDef != null) && (!attDef.Constant))
                {
                    using (AttributeReference attRef 
                                    = new AttributeReference())
                    {
                        attRef.SetAttributeFromBlock(
                                 attDef, bref.BlockTransform);
 
                        _attDisps.Add(attRef.Tag, 
                                     attRef.Position - midPt);
                    }
                }
            }
 
            // Stores the positions of the attributes in the 
            // rotated state.
            _attPos = new Dictionary<string, Point3d>();
 
 
            // The block reference rotation was set to 0.0 
            // for calculating extents. 
            // We do not want to save that change
            //tr.Commit();
        }
    }
 
    public bool DoIt()
    {
        Editor ed 
        = Application.DocumentManager.MdiActiveDocument.Editor;
 
        PromptResult jigRes = null;
        jigRes = null;
        jigRes = ed.Drag(this);
        if (jigRes.Status != PromptStatus.OK)
            return false;
        return true;
    }
 
    protected override SamplerStatus Sampler(JigPrompts prompts)
    {
        JigPromptAngleOptions jigOpts = new JigPromptAngleOptions();
        jigOpts.UserInputControls = 
                (UserInputControls.Accept3dCoordinates | 
                 UserInputControls.NullResponseAccepted);
 
        jigOpts.Message = "Specify rotation :";
        jigOpts.BasePoint = _insPoint;
        jigOpts.UseBasePoint = true;
        jigOpts.Cursor = CursorType.RubberBand;
        PromptDoubleResult jigRes = prompts.AcquireAngle(jigOpts);
 
        double angle = jigRes.Value;
 
        if (_brefAngle == angle)
            return SamplerStatus.NoChange;
 
        _brefAngle = angle;
 
        if (jigRes.Status == PromptStatus.OK)
            return SamplerStatus.OK;
 
        return SamplerStatus.Cancel;
    }
 
    protected override bool WorldDraw(
            Autodesk.AutoCAD.GraphicsInterface.WorldDraw draw)
    {
        using (BlockReference bref 
                       = new BlockReference(_insPoint, _btrId))
        {
            Database db = HostApplicationServices.WorkingDatabase;
            using (Transaction tr 
                    = db.TransactionManager.StartTransaction())
            {
                BlockTableRecord btr = tr.GetObject(
                _btrId, OpenMode.ForRead) as BlockTableRecord;
 
                foreach (ObjectId id in btr)
                {
                    DBObject obj = id.GetObject(OpenMode.ForRead);
                    AttributeDefinition attDef 
                                  = obj as AttributeDefinition;
                    if ((attDef != null) && (!attDef.Constant))
                    {
                        using (AttributeReference attRef 
                                    = new AttributeReference())
                        {
                            attRef.SetAttributeFromBlock
                                 (attDef, bref.BlockTransform);
 
                            Point3d midPt = _attExts.MinPoint 
                            + (_attExts.MaxPoint-_attExts.MinPoint) 
                                                        * 0.5;
 
                            Vector3d dir = midPt - bref.Position;
 
                            dir = dir.RotateBy(
                                   _brefAngle, Vector3d.ZAxis);
 
                            midPt = bref.Position.TransformBy
                                 (Matrix3d.Displacement(dir));
 
                            if (_attDisps.ContainsKey(attRef.Tag))
                            {
                                Point3d attPos = 
                                midPt.TransformBy(
                                Matrix3d.Displacement(
                                       _attDisps[attRef.Tag]));
 
                                attRef.Position = attPos;
 
                                if (_attPos.ContainsKey(attRef.Tag))
                                    _attPos[attRef.Tag] = attPos;
                                else
                                    _attPos.Add(attRef.Tag, attPos);
 
                                draw.Geometry.Draw(attRef);
                            }
                        }
                    }
                }
                tr.Commit();
            }
 
            bref.Rotation = _brefAngle;
            draw.Geometry.Draw(bref);
        }
        return true;
    }
}

Here is a sample drawing to try the "BJig" command. Download Test

Posted at 11:57 AM in .NET, 2012, 2013, 2014, Balaji Ramamoorthy | Permalink | Comments (1)

AutoCAD DevBlog

2012

02/15/2014

3DWalk through an AutoCAD Model

02/09/2014

Making Custom entity GripMode aware

12/30/2013

Running a Tool from ToolPalette

12/18/2013

Grip context menu using AcDbMultiModesGripPE

11/28/2013

Overruling grips for a Group

11/27/2013

Inserting RasterImage using image buffer

11/09/2013

DrawableOverrule to highlight entities in nested block references and Xrefs

11/01/2013

Importing ToolPalette/ToolPaletteGroup from XTP/XPG files

10/22/2013

Accessing extension dictionary of an overruled entity while dragging

10/17/2013

Keeping attributes horizontal while rotating a block using Jig

Search

AutoCAD DevBloggers

July 2024

Autodesk Blogs

Recent Posts

Recent Comments

Archives

Sun	Mon	Tue	Wed	Thu	Fri	Sat
	1	2	3	4	5	6
7	8	9	10	11	12	13
14	15	16	17	18	19	20
21	22	23	24	25	26	27
28	29	30	31

2012

02/15/2014

02/09/2014

12/30/2013

12/18/2013

11/28/2013

11/27/2013

11/09/2013

11/01/2013

10/22/2013

10/17/2013

Search

AutoCAD DevBloggers

July 2024

Autodesk Blogs

Share

Recent Posts

Recent Comments