AutoCAD DevBlog

Opening a P&ID Drawing that was edited offline (avoiding the Update dialog)

By Wayne Brill

A drawing that was edited offline has to be re-inserted (merged) into the project. Plant drawings contain subset of project database (BLOB as SQL database). Plant also a knows whether the drawing was saved in the current project or not. If drawing was not saved in the current project, the BLOB has to be merged into the project.

There are several API to handle this situation:

Project.IsDrawingOutOfSync(string dwgname, Database db) – tells whether AcDbDatabase is in sync with project database

Project.UpdatePnPDrawing(Database db, string dwgname, ref PnPSyncConflicts conflicts) – merge blob into project database.

C# example:

[CommandMethod("testOpen", CommandFlags.Session)]

public void testOpen()

{

    string strDwgPath;

    Database db = new Database(false, true);

 

    Project currentProject =

        PlantApp.CurrentProject.ProjectParts["PnId"];

    DataLinksManager dlm =

                     currentProject.DataLinksManager;

 

    // get project drawing 

    PnPProjectDrawing pnp_dwg =

        currentProject.GetDwgFileByName

        ("C:\\MyProject\\PID DWG\\PumpAnlage.dwg");

 

    // use resolved path

    strDwgPath = pnp_dwg.ResolvedFilePath;

 

 

    db.ReadDwgFile(strDwgPath,

                FileShare.ReadWrite, false, null);

    // tell DLM to manage drawing database.

    //(Documents are automatically enlisted

    //when they are opened in editor)

    dlm.EnlistDrawing(db);

    // dispose will unelist it

 

    if (currentProject.IsDrawingOutOfSync

                              (strDwgPath, db))

    {

 

        PnPSyncConflicts conflicts = null;

        currentProject.UpdatePnPDrawing

                (db, strDwgPath, ref conflicts);

        // tell DLM that drawing related data has to

        // be saved in the project database.

        // otherwise, DLM will not save drawing sync

        // timestamp causing out-of-sync

        // situation on drawing open

      DataLinksManager.DatabaseToForceSaveComplete

                                             = db;

        try

        {

            db.SaveAs(strDwgPath, DwgVersion.Current);

        }

        catch (System.Exception ex)

        {

 

        }

        finally

        {

          DataLinksManager.DatabaseToForceSaveComplete

                                               = null;

 

        }

    }

 

 

    db.CloseInput(true);

    db.Dispose();

 

    DocumentCollection acDocMgr =

                         Application.DocumentManager;

 

    Document acDoc = acDocMgr.Open(strDwgPath, false);

 

    AcadDocument anAcadDoc =

               (AcadDocument)acDoc.GetAcadDocument();

    // if(!anAcadDoc.Saved)

        anAcadDoc.Save();

 

}

VBA macro compatibility in AutoCAD 2014 64-bit

By Stephen Preston

I've been handling quite a few questions recently from customers migrating to AutoCAD 2014 64-bit from an earlier 64-bit AutoCAD version. The typical problem is something like this:

My VBA macro is referencing some additional OCX control or Type Library. It worked fine on AutoCAD 64-bit versions prior to AutoCAD 2014. But now my macro generates an error related to that Type Library or OCX control.

The explanation for this is that AutoCAD 2014 is the first AutoCAD release to use Microsoft's newer VBA 7.1 engine, where older AutoCAD versions used the VBA 6.3 engine. VBA 6.3 was available as a 32-bit component only. VBA 7.1 is available as 32-bit and 64-bit components - and (as you'd expect) AutoCAD 2014 64-bit uses the 64-bit component. Your Type Library/OCX control can't be loaded because it is a 32-bit component. It is impossible to load any 32-bit component into a 64-bit process space. This is the reason for your error.

In order to make your macro work again, you must replace your 32-bit component with a 64-bit version - or refactor your project to use an alternative if the vendor of that component doesn't provide a 64-bit version.

The reason the same VBA macro worked in older AutoCAD 64-bit versions is because AutoCAD launched VBA 6.3 in a separate (32-bit) process to which AutoCAD marshals its COM calls. So, although AutoCAD was running 64-bit native, the VBA engine was still a 32-bit process and could happily load 32-bit components.

VBA being run in a separate process like this is also the reason why VBA macros used to be about 30 times slower running in AutoCAD 64-bit compared to AutoCAD 32-bit. The new VBA 7.1 engine fixes that problem for AutoCAD 2014 64-bit.

 

3DWalk through an AutoCAD Model

By Balaji Ramamoorthy

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.

Detecting entities under cursor while selection is running

By Philippe Leefsma

The PointMonitor callback in .Net lets you access the entities that are under the cursor aperture as the user is hovering the mouse, however this feature gets disabled while running an Editor.GetEntity.

There is a workaround for that behavior that involves P/Invoking a bunch of ObjectARX methods, as we like to do. Below is a C# sample for that.

Nested entities can also be detected as exposed in this previous post:

Retrieving nested entities under cursor aperture using .Net API

 

class ArxImports

{

    public struct ads_name

    {

        public IntPtr a;

        public IntPtr b;

    };

 

    [StructLayout(LayoutKind.Sequential, Size = 32)]

    public struct resbuf { }

 

    [DllImport("accore.dll",

        CallingConvention = CallingConvention.Cdecl,

        CharSet = CharSet.Unicode,

        ExactSpelling = true)]

    public static extern PromptStatus acedSSGet(

        string str, IntPtr pt1, IntPtr pt2,

        IntPtr filter, out ads_name ss);

 

    [DllImport("accore.dll",

        CallingConvention = CallingConvention.Cdecl,

        CharSet = CharSet.Unicode,

        ExactSpelling = true)]

    public static extern PromptStatus acedSSFree(

        ref ads_name ss);

 

    [DllImport("accore.dll",

        CallingConvention = CallingConvention.Cdecl,

        CharSet = CharSet.Unicode,

        ExactSpelling = true)]

    public static extern PromptStatus acedSSLength(

        ref ads_name ss, out int len);

 

    [DllImport("accore.dll",

        CallingConvention = CallingConvention.Cdecl,

        CharSet = CharSet.Unicode,

        ExactSpelling = true)]

    public static extern PromptStatus acedSSName(

        ref ads_name ss, int i, out ads_name name);

 

    [DllImport("acdb19.dll",

        CallingConvention = CallingConvention.Cdecl,

        CharSet = CharSet.Unicode,

        ExactSpelling = true)]

    public static extern ErrorStatus acdbGetObjectId(

        out ObjectId id, ref ads_name name);

}

 

static System.Collections.Generic.List<ObjectId>

    FindAtPoint(Point3d worldPoint, bool selectAll = true)

{

    System.Collections.Generic.List<ObjectId> ids =

        new System.Collections.Generic.List<ObjectId>();

 

    Document doc = Application.DocumentManager.MdiActiveDocument;

 

    Matrix3d wcs2ucs =

        doc.Editor.CurrentUserCoordinateSystem.Inverse();

 

    Point3d ucsPoint = worldPoint.TransformBy(wcs2ucs);

          

    string arg = selectAll ? ":E" : string.Empty;

          

    IntPtr ptrPoint = Marshal.UnsafeAddrOfPinnedArrayElement(

        worldPoint.ToArray(), 0);

 

    ArxImports.ads_name sset;

 

    PromptStatus prGetResult = ArxImports.acedSSGet(

        arg, ptrPoint, IntPtr.Zero, IntPtr.Zero, out sset);

 

    int len;

    ArxImports.acedSSLength(ref sset, out len);

 

    if (len <= 0)

        return ids;

          

    for (int i = 0; i < len; ++i)

    {

        ArxImports.ads_name name;

 

        if (ArxImports.acedSSName(

            ref sset, i, out name) != PromptStatus.OK)

            continue;

               

        ObjectId id;

 

        if (ArxImports.acdbGetObjectId(

            out id, ref name) != ErrorStatus.OK)

            continue;

 

        ids.Add(id);

    }

 

    ArxImports.acedSSFree(ref sset);

 

    return ids;

}

 

Editor AdnEditor;

 

[CommandMethod("PointMonitorSelection")]

public void PointMonitorSelection()

{

    Document doc = Application.DocumentManager.MdiActiveDocument;

    Database db = doc.Database;

    Editor ed = doc.Editor;

 

    try

    {

        AdnEditor = doc.Editor;

 

        AdnEditor.PointMonitor +=

            FindUsingPointMonitor;

       

        PromptEntityOptions peo = new PromptEntityOptions(

            "Select an entity...");

 

        PromptEntityResult per = ed.GetEntity(peo);

 

        if (per.Status != PromptStatus.OK)

            return;

 

        ObjectId id = per.ObjectId;

 

        ed.WriteMessage("\n - Selected " +

            " Entity: " + id.ObjectClass.Name +

            " Id: " + id.ToString());

    }

    catch(System.Exception ex)

    {

        ed.WriteMessage("\nException: " + ex.Message);

    }

    finally

    {

        AdnEditor.PointMonitor -=

            FindUsingPointMonitor;

    }

}

 

void FindUsingPointMonitor(object sender, PointMonitorEventArgs e)

{

    Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;

 

    // Not working when running editor selection

    //foreach (var subId in e.Context.GetPickedEntities())

    //{

    //    foreach (var id in subId.GetObjectIds())

    //    {

    //        ed.WriteMessage("\n - " +

    //            " Entity: " + id.ObjectClass.Name +

    //            " Id: " + id.ToString());

    //    }

    //}

 

    var ids = FindAtPoint(e.Context.RawPoint);

 

    foreach (var id in ids)

    {

        ed.WriteMessage("\n + " +

            " Entity: " + id.ObjectClass.Name +

            " Id: " + id.ToString());

    }

}

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);

}

Deploying RealDWG application using WiX

By Balaji Ramamoorthy

Here is a sample project from RealDWG DevTV that has been modified to use WiX to deploy the application.

To try this, please download and install the WiX Toolset.

There are two batch files included in the sample project folder. These batch files run as "Pre-build event" when the project is built. Please ensure that the path of the VC++ re-distributables, Fonts and other RealDWG merge modules are correctly specified in the batch files.

The purpose of the batch files is to copy all the files needed for the packaging to a common folder named as "ForPackaging". The WiX setup project builds the MSI by using this folder path without having to look for files in different paths.

Download MyRealDWG_Sample