AutoCAD DevBlog

How to embed a property inspector control into a palette

By Madhukar Moogala

This is old SDK Sample I have resurrected for better reach, the code is migrated to work with AutoCAD 2023.

This sample demonstrates deriving from CAdUiPalette and CAdUiPaletteSet.

· How to persist palette data into an XML file, and to re-establish the palette set when newly created.

· How to embed a property inspector control into a palette.

· How to create a custom property editor ActiveX control (CDWGPreview).

Source :

https://github.com/MadhukarMoogala/CustPalette

How to Exit from AutoCAD or AutoCAD OEM

By Madhukar Moogala

There may be a situation where your Arx application needs to exit AutoCAD if the license check or some other business logic fails

When aborting, use AcDbHostApplicationServices::fatalError()

Or, acrx_abort() instead of a direct or indirect call to exit().This will allow AutoCAD and other ObjectARX applications to recover as much work as possible. Always use API calls rather than system calls.

It is highly desirable for the RealDWG host application to override this method, and do whatever needs to be done for a clean and graceful shutdown. For example, allowing the user to save some portion of the work in progress, cleaning up memory allocations, and so on are all things that should be done upon a fatal error.

extern "C" AcRx::AppRetCode
acrxEntryPoint(AcRx::AppMsgCode msg, void* pkt)
{
	AcRx::AppRetCode retVal = AcRx::kRetOK;
	switch (msg)
	{
	case AcRx::kInitAppMsg:
		//acrxDynamicLinker->unlockApplication(pkt);
		//acrxRegisterAppMDIAware(pkt);
		//initApp();

		// perform license check
		retVal = checkLicense();
		if (retVal == AcRx::kRetOK)
		{
			acrxDynamicLinker->unlockApplication(pkt);
			acrxRegisterAppMDIAware(pkt);
			initApp();
		}
		else
		{
			MessageBox(adsw_acadMainWnd(),
			L"Application should not be allowed to load.", L"Start-up Error", MB_OK + MB_ICONWARNING);
			acrx_abort(L"Invalid License: Application Quits Now");
			//or
			//acdbHostApplicationServices()->fatalError(_T("Application is Quitting Now"));					
			return AcRx::kRetError;
		}
		break;
	case AcRx::kUnloadAppMsg:
		unloadApp();
		break;
	default:
		break;

	}

	//return AcRx::kRetOK;
	return retVal;

}

BlockView Sample Refactored

By Madhukar Moogala

BlockView is an ObjectARX graphics sample which use to be shipped with ObjectARX in previous year

I've recently recieved a request from an ADN partner

The problem

If we are running in 2022 or 2023 and we have Hardware Acceleration turned ON. We get some graphics not showing up in our CGsPreviewCtrl. Specifically the void CGsPreviewCtrl::RubberRectangle(CPoint startPt, CPoint endPt) will not display on the view. Again, this only occurs in AutoCAD 2022 & 20223, on Windows 11 with Hardware Acceleration turned ON. If we turn OFF hardware acceleration it works, or if we run on Windows 10 or if on AutoCAD 2021 and before it appears to work.

Reason

We start to support DX12 from AutoCAD 2022. DX12 uses flip mode but GDI uses blit mode. The issue happens because the below code attempt to use GDI to draw over a Window used by DX12.

void CGsPreviewCtrl::RubberRectangle(CPoint startPt, CPoint endPt) 
{
  // get the device context for the client area
  CDC *cdc = this->GetDC();
  // if ok
  if (cdc != NULL)
  {
    HDC hdc = cdc->GetSafeHdc();
    // Create a black pen with a dotted style to draw the border of the rectangle.
    HPEN gdiPen = CreatePen(PS_DOT, 1, RGB(0,0,0));
    // Set the ROP cdrawint mode to XOR.
    SetROP2(hdc, R2_XORPEN);

    // Select the pen into the device context.
    HGDIOBJ oldPen = SelectObject(hdc, gdiPen);

    // Create a stock NULL_BRUSH brush and select it into the device
    // context so that the rectangle isn't filled.
    HGDIOBJ oldBrush = SelectObject(hdc, GetStockObject(NULL_BRUSH) );

    // Now XOR the hollow rectangle on the Graphics object with
    // a dotted outline.
    Rectangle(hdc, startPt.x, startPt.y, endPt.x, endPt.y);

    // Put the old stuff back where it was.
    SelectObject(hdc, oldBrush); // no need to delete a stock object
    SelectObject(hdc, oldPen);
    DeleteObject(gdiPen);		// but we do need to delete the pen

    // Return the device context to Windows.
    this->ReleaseDC(cdc);
  }
}

It is highly recommended to move away from GDI API

In case you can't invest in upgrading the code, you can use following workaround to set GFXDX12=0 and close AutoCAD, it will switch to DX11

We updated the old Arx sample to work effectively without switching to DX11 in AutoCAD 2022 and later version.

Github - BlockView

Guideline to use Autodesk Product Icons in 3rd Apps.

By Madhukar Moogala

Autodesk external developers may need or want to use our product icons on their apps for a cohesive design, however, using Autodesk product icons without written expression of permission is not recommended.

So if you are developer who is using or planning to use, you need to submit the permission to Autodesk.

Autodesk Permissions Workflow found here.

In case if the link breaks - https://autodesk.tap.thinksmart.com/prod/Portal/ShowWorkFlow/AnonymousEmbed/cf050d55-075d-4da3-9423-db7e85ced572

Embedding an image in a drawing

By Balaji Ramamoorthy

In this blog post we will look at creating a custom object derived from AcDbRasterImageDef that saves/loads the image data to/from the drawing using ATIL. This will ensure that your drawing is independent of the external image file and the image data will get loaded to the AcDbRasterImageDef if the arx is loaded in AutoCAD.

For other ways to embed an image in a drawing without having a dependency on an external image file, please refer to this blog post :

Embedding an image in a drawing

 // AcDbMyRasterImageDef.h 

 class  DLLIMPEXP AcDbMyRasterImageDef : 

 	public  AcDbRasterImageDef 

 {

 protected :

 	static  Adesk::UInt32 kCurrentVersionNumber;

 public :

 	ACRX_DECLARE_MEMBERS(AcDbMyRasterImageDef) ;

 	AcDbMyRasterImageDef () ;

 	virtual  ~AcDbMyRasterImageDef () ;

 	virtual  Acad::ErrorStatus 

 		dwgOutFields (AcDbDwgFiler *pFiler) const  ;

 	virtual  Acad::ErrorStatus dwgInFields 

 		(AcDbDwgFiler *pFiler) ;

 	//----- deepClone 

 	virtual  Acad::ErrorStatus 

 		subDeepClone (AcDbObject *pOwnerObject, 

 		AcDbObject *&pClonedObject, AcDbIdMapping &idMap, 

 		Adesk::Boolean isPrimary =true ) const  ;

 	//----- wblockClone 

 	virtual  Acad::ErrorStatus subWblockClone 

 		(AcRxObject *pOwnerObject, AcDbObject *&pClonedObject, 

 		AcDbIdMapping &idMap, Adesk::Boolean isPrimary =true )

 		const  ;

 	Acad::ErrorStatus 

 		setEmbeddedImage(const  ACHAR* imageFilePath);

 private :

 	void  *operator  new [](size_t) throw (){ return  (void *)0;}

     void  operator  delete [](void  *) {};

     void  *operator  new [](size_t , const  char  *, int  ) throw ()

 	{ return  (void *)0;}

 	Atil::Image *m_pAtilImage;

 };

 // AcDbMyRasterImageDef.cpp 

 AcDbMyRasterImageDef::AcDbMyRasterImageDef () 

 	: AcDbRasterImageDef () 

 {

 	m_pAtilImage = NULL;

 }

 AcDbMyRasterImageDef::~AcDbMyRasterImageDef() 

 {

 	if (m_pAtilImage != NULL)

 	{

 		delete  m_pAtilImage;

 		m_pAtilImage = NULL;

 	}

 }

 Acad::ErrorStatus AcDbMyRasterImageDef::dwgOutFields

 	(AcDbDwgFiler *pFiler) const  {

 	assertReadEnabled () ;

 	//----- Save parent class information first. 

 	Acad::ErrorStatus es =

 		AcDbRasterImageDef::dwgOutFields (pFiler) ;

 	if  ( es != Acad::eOk )

 		return  (es) ;

 	//----- Object version number needs to be saved first 

 	if  ( (es =pFiler->writeUInt32 

 		(AcDbMyRasterImageDef::kCurrentVersionNumber))

 		!= Acad::eOk )

 		return  (es) ;

 	if (m_pAtilImage)

 	{

 		Atil::Size size = m_pAtilImage->size();

 		Int32 width = size.width;

 		Int32 height = size.height;

 		pFiler->writeInt32(width);

 		pFiler->writeInt32(height);

 		// Write the image data on to the Atil image 

 		// using an Image Context 

 		Atil::Offset upperLeft(0,0);

 		Atil::ImageContext *pImgContext 

 			= m_pAtilImage->createContext(

 				Atil::ImageContext::kRead,

 				size,

 				upperLeft);

 		if  (pImgContext != NULL)

 		{

 			for  (int  xf=0;xf<width;xf++)

 			{

 				for  (int  yf=0;yf<height;yf++)

 				{

 					Atil::RgbColor p;

 					p = pImgContext->get32(xf, yf);

 					pFiler->writeInt32(p.packed);

 				}

 			}

 		}

 		pImgContext->flush();

 		delete  pImgContext;

 	}

 	return  (pFiler->filerStatus ()) ;

 }

 Acad::ErrorStatus AcDbMyRasterImageDef::dwgInFields

 	(AcDbDwgFiler *pFiler) 

 {

 	assertWriteEnabled () ;

 	Acad::ErrorStatus es =

 		AcDbRasterImageDef::dwgInFields (pFiler) ;

 	if  ( es != Acad::eOk )

 		return  (es) ;

 	Adesk::UInt32 version =0 ;

 	if  ( (es =pFiler->readUInt32 (&version)) 

 		!= Acad::eOk )

 		return  (es) ;

 	if  ( version > 

 		AcDbMyRasterImageDef::kCurrentVersionNumber)

 		return  (Acad::eMakeMeProxy) ;

 	Int32 width = 0;

 	Int32 height = 0;

 	pFiler->readInt32(&width);

 	pFiler->readInt32(&height);

 	// Create an Atil::Image. 

     // The AcDbRasterImageDef::setImage requires it 

     Atil::ImagePixel initialImage;

     initialImage.setToZero();

     initialImage.type 

 		= Atil::DataModelAttributes::kBgra;

     initialImage.value.rgba = 0xff000000;

     Atil::Size size(width, height);

     const  Atil::RgbModel *pDm 

 		= new  Atil::RgbModel(

         Atil::RgbModelAttributes::k4Channels,

         Atil::DataModelAttributes::kBlueGreenRedAlpha);

 	if (m_pAtilImage != NULL)

 	{

 		delete  m_pAtilImage;

 		m_pAtilImage = NULL;

 	}

     m_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 

 		= m_pAtilImage->createContext(

 				Atil::ImageContext::kWrite,

 				size,

 				upperLeft);

 	if  (pImgContext != NULL)

 	{

 		for  (int  xf=0;xf<width;xf++)

 		{

 			for  (int  yf=0;yf<height;yf++)

 			{

 				Int32 value;

 				pFiler->readInt32(&value);

 				pImgContext->put32(xf, yf, value);

 			}

 		}

 	}

 	pImgContext->flush();

 	delete  pImgContext;

 	setImage (m_pAtilImage, NULL) ;

 	return  (pFiler->filerStatus ()) ;

 }

 //----- deepClone 

 Acad::ErrorStatus AcDbMyRasterImageDef::subDeepClone 

 	(AcDbObject *pOwnerObject, AcDbObject *&pClonedObject, 

 	AcDbIdMapping &idMap, Adesk::Boolean isPrimary) const  

 {

 	assertReadEnabled () ;

 	return  (AcDbRasterImageDef::subDeepClone 

 		(pOwnerObject, pClonedObject, idMap, isPrimary)) ;

 }

 //----- wblockClone 

 Acad::ErrorStatus AcDbMyRasterImageDef::subWblockClone 

 	(AcRxObject *pOwnerObject, AcDbObject *&pClonedObject, 

 	AcDbIdMapping &idMap, Adesk::Boolean isPrimary) const  

 {

 	assertReadEnabled () ;

 	return  (AcDbRasterImageDef::subWblockClone 

 		(pOwnerObject, pClonedObject, idMap, isPrimary)) ;

 }

 Acad::ErrorStatus  AcDbMyRasterImageDef::setEmbeddedImage

 							(const  ACHAR* imageFilePath)

 {

     AcString imagePath(imageFilePath);

     AcTcImage tc;

     tc.Load(imagePath);

     HBITMAP bmp=0;

     tc.GetHBITMAP(RGB(0xff,0xff,0xff),bmp);

     if  (bmp == NULL)

 		return  Acad::eFileNotFound;

     BITMAP _bmp={0};

     GetObject(bmp,sizeof  BITMAP,&_bmp);

     HDC hdcScr=GetDC(NULL);

     HDC    hdcMem=CreateCompatibleDC(hdcScr);

     SelectObject(hdcMem,bmp);

     Atil::ImagePixel initialImage;

     initialImage.setToZero();

 	initialImage.type = Atil::DataModelAttributes::kBgra;

     initialImage.value.rgba = 0xff000000;

     Atil::Size size(_bmp.bmWidth, _bmp.bmHeight);

     const  Atil::RgbModel *pDm = new  Atil::RgbModel(

         Atil::RgbModelAttributes::k4Channels,

         Atil::DataModelAttributes::kBlueGreenRedAlpha);

 	if (m_pAtilImage != NULL)

 	{

 		delete  m_pAtilImage;

 		m_pAtilImage = NULL;

 	}

     m_pAtilImage 

 		= new  Atil::Image(size, pDm, initialImage);

     Atil::Offset upperLeft(0,0);

     Atil::ImageContext *pImgContext

         = m_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= 0xff;

                 COLORREF pix=GetPixel(hdcMem,xf,yf);

                 BYTE rr = (pix&0xff);

                 BYTE gg = (pix>>8)&0xff;

                 BYTE bb = (pix>>16)&0xff;

                 Atil::RgbColor p;

                 p.set(rr, gg, bb, alpha);

                 pImgContext->put32(xf, yf, p);

             }

         }

     }

     pImgContext->flush();

     delete  pImgContext;

     bool  isImageValid = m_pAtilImage->isValid();

     assert(isImageValid);

     // Cleanup 

     DeleteDC(hdcMem);

     ReleaseDC(NULL,hdcScr);

     DeleteObject( bmp);

 	return  setImage (m_pAtilImage, NULL) ;

 }

 // Embed image command 

 static  void  AdskMyTestEmbedImage(void )

 {

 	AcDbMyRasterImageDef *pImageDef 

 		= new  AcDbMyRasterImageDef();

 	pImageDef->setEmbeddedImage(

 		ACRX_T("D:\\TestFiles\\MyTexture.jpg" ));

 	Acad::ErrorStatus es 

 		= InsertImageInDwg(pImageDef);

 	if (es != Acad::eOk)

 	{

 		delete  pImageDef;

 		return ;

 	}

 }

 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("RASTER_USING_BUFFER" );

 	BOOL bExist = pDict->has(DICT_NAME);

 	AcDbObjectId objID = AcDbObjectId::kNull;

 	if  (!bExist)

 	{

 		es = pDict->setAt(DICT_NAME, pImageDef, objID);

 		if (es != Acad::eOk)

 		{

 			pDict->close();

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

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

 	return  Acad::eOk;

 }

 virtual  AcRx::AppRetCode On_kInitAppMsg (void  *pkt) 

 {

 	AcRx::AppRetCode retCode =

 		AcRxArxApp::On_kInitAppMsg (pkt) ;

 	acrxDynamicLinker->loadModule

 		(L"acismobj20.dbx" ,true ); 

 	AcDbMyRasterImageDef::rxInit();

 	acrxBuildClassHierarchy();

 	return  (retCode) ;

 }

The sample project can be downloaded here :

Download EmbedImage

If you are looking to create an embedded raster image using the AutoCAD .Net API, a way to do it is by creating a managed wrapper for the custom object that we created. A .Net only solution is not possible at present since custom objects can only be created using C++. Also, ATIL is a C++ only library which we use in this case.

A way to access it in .Net is demonstrated in the following sample project. To try this sample, appload the .arx and netload the managed wrapper and custom .Net module. Run the "EmbedImageMgd" command.

Download CustomRasterImageDef

 

Update:

the broker code is fixed and updated to ObjectARX 2022, is posted in Github

https://github.com/MadhukarMoogala/EmbedRasterImage

 

Is it possible to emulate command LIVESECTION with AutoCAD .NET AP

By Madhukar Moogala

This question is coming from one of our beloved Forum contributor and Mentor Alexander Rivilis

I am working with code which change color of Intersection Fill of Live Section. But although the color is changed, but this is not visible on the screen until I turn off and turn LIVESECTION:

I made slight changes to have this working

Note: To work this make sure LIVESECTION is not turned on

This code will change color of SECTION which converted to LIVESECTION

    public void SetSectionColor()
       {
          Document doc = Application.DocumentManager.MdiActiveDocument;
          if (doc == null) return;
          Editor ed = doc.Editor;

          PromptEntityOptions peo = 
                new PromptEntityOptions("\nSelect section: ");
          peo.SetRejectMessage("\nIt is not a section!");
          peo.AddAllowedClass(typeof(Section), true);
          PromptEntityResult per = ed.GetEntity(peo);
          if (per.Status != PromptStatus.OK) return;
          ObjectId idSecSets = ObjectId.Null;
          using (Transaction tr =
          doc.TransactionManager.StartOpenCloseTransaction())
          {
              Section sec =
              tr.GetObject(per.ObjectId,
                           OpenMode.ForWrite) as Section;
              sec.IsLiveSectionEnabled = true;                
              idSecSets = sec.Settings;
              tr.Commit();
          }
        using (Transaction tr = doc.TransactionManager
                                     .StartOpenCloseTransaction())
        {
          SectionSettings secset = tr.GetObject(idSecSets, 
                                   OpenMode.ForWrite) as SectionSettings;
          secset.CurrentSectionType = SectionType.LiveSection;
          Color clr = secset.Color(SectionType.LiveSection,
                                   SectionGeometry.IntersectionFill);
          ColorDialog cd = new ColorDialog
          {
              Color = clr
          };
          System.Windows.Forms.DialogResult dr = cd.ShowDialog();
          if (dr != System.Windows.Forms.DialogResult.OK) return;
          ed.WriteMessage("\nSelected Color: " + cd.Color.ToString());
          clr = cd.Color;
          // Define that color we change
          secset.SetColor(SectionType.LiveSection,
          SectionGeometry.IntersectionFill, clr);
          tr.Commit();
        }  
    }

Gif

Using Entitlement API within ObjectARX C++

By Madhukar Moogala

We have .NET (C#) example on how to secure and protect your app on AutoCAD and other Autodesk products, for AutoCAD, Kean has written long back

For Revit – A blog from Mikako

For Fusion 360 – A C++ code, which I used most part of it and made few changes to best fit with AutoCAD

There is an introductory briefing on Entitlement API by Daniel.

For reading brevity, I will give simple statement what it brings to the table.

Entitlement API is a rest enabled API, allows you to check if the user is entitled to access your app i.e., user has bought the app from Autodesk App Store

To call Rest API with in ObjectARX, we need to use a Rest Client, for this I’m using restclient-cpp from mrtazz, a Json library to parse the response and make code more readable (this an optional not a must to run the sample)

Full instructions to build the sample is provided in Github

		if (getUserId()[0] == _T('\0')) {
			//User is not logged in, we will prompt to login!
			onlineUI();
		}
		//plumbing wide
		TCHAR buffer[512];
		acedGetString(0,_T("Enter AppId To Test CheckEntitlement:\t"), buffer);
		string userId = toNarrow(getUserId().kwszPtr());	 
		string appId = toNarrow(buffer);
		string url ="https://apps.exchange.autodesk.com/webservices/checkentitlement"+
					string("?userid=") + userId + string("&appid=") + appId;
		RestClient::Response response = RestClient::get(url);

		Json::Reader reader;
		Json::Value root;

		bool isparseSuccessful = reader.parse(response.body, root);
		if (!isparseSuccessful) {
			acutPrintf(_T("Error parsing URL"));
		}
		if ((root["IsValid"].asString()) == "true")
		{
			acutPrintf(_T("IsValid is True"));
		}
		else
		{
			acutPrintf(_T("IsValid is False"));
		}

Working Gif - https://pasteboard.co/JgZaD71.gif

ObjectARX 2021: Link Errors With VS 2019

By Madhukar Moogala

Q: We are getting link error compiling code for AutoCAD 2021 with Visual Studio 2019 and ObjectARX SDK 2021.

A. The AutoCAD code for 3D modelling entities namely AcDbSubDMesh, AcDb3dSolid, AcDbRegion, AcDbAsmBody, AcDbShape etc are now ported to new library AcGeomEnt.lib

The declaration for almost all 3D entities are moved AcGeomEnt.lib, you need to link your source code with AcGeomEnt.lib which is present in <SDK>\lib-x64\

And, you may also need to appload  the AcGeomentObj.dbx in case if you are reading a drawing with 3D entities in side databases.

Detecting Geometric Center for LWPOLYLINE ,3DPoly and 2DPoly

By Madhukar Moogala

Unfortunately there is no direct API to detect geometric center for three classifications of polylines, one may use Topology libraries to find out, or preferably the easiest at least for me is to convert the LWPOLYLINE, AcDb2dPolyline,AcDb3dPolyline to an in-memory region, apply area properties API to fetch Geometric Center.

[CommandMethod("GCTR")]
public static void GC() {

 var doc = AcCoreApp.DocumentManager.MdiActiveDocument;
 var db = doc.Database;
 var ed = doc.Editor;
 var tid = ObjectId.Null;
 Point2d centroid = Point2d.Origin;

 using(Transaction tr = db.TransactionManager.StartTransaction()) {
  try {

   TypedValue[] acTypValAr = {
    new TypedValue((int) DxfCode.Operator, "")
   };
   // Assign the filter criteria to a SelectionFilter object
   SelectionFilter acSelFtr = new SelectionFilter(acTypValAr);
   // Request for objects to be selected in the drawing area
   PromptSelectionResult acSSPrompt;
   acSSPrompt = ed.GetSelection(acSelFtr);

   // If the prompt status is OK, objects were selected
   if (acSSPrompt.Status == PromptStatus.OK) {
    SelectionSet acSSet = acSSPrompt.Value;
    foreach(SelectedObject so in acSSet) {
     var pline = tr.GetObject(so.ObjectId, OpenMode.ForRead) as Entity;
     //Convert entity to in-memory Region.
     using(DBObjectCollection segments = new DBObjectCollection()) {
      pline.Explode(segments);
      DBObjectCollection regions = Region.CreateFromCurves(segments);
      foreach(Region r in regions) {
       //to get the centroid of a region lying on the WCS XY plane:
       Point3d origin = Point3d.Origin;
       Vector3d xAxis = Vector3d.XAxis;
       Vector3d yAxis = Vector3d.YAxis;
       centroid = r.AreaProperties(ref origin, ref xAxis, ref yAxis).Centroid;
       CenterMarkEntity(centroid);
      }


     }
     ed.WriteMessage($ "\nGeometricCenter of {pline.GetRXClass().DxfName}:{centroid}");
    }
    tr.Commit();
   } else {
    Autodesk.AutoCAD.ApplicationServices.Core.Application.ShowAlertDialog("Number of objects selected: 0");
   }


  } catch (Autodesk.AutoCAD.Runtime.Exception ex) {
   ed.WriteMessage(ex.ToString());
  }
 }


}

public static void CenterMarkEntity(Point2d p) {
  var doc = AcCoreApp.DocumentManager.MdiActiveDocument;
  var db = doc.Database;
  var ed = doc.Editor;
  using(Transaction t = db.TransactionManager.StartTransaction()) {
   short mode = (short) AcCoreApp.GetSystemVariable("PDMODE");
   if (mode == 0) {
    AcCoreApp.SetSystemVariable("PDMODE", 99);
   }
   var ms = t.GetObject(SymbolUtilityServices.GetBlockModelSpaceId(db), OpenMode.ForWrite) as BlockTableRecord;
   DBPoint dbPt = new DBPoint(new Point3d(p.X, p.Y, .0)) {
    ColorIndex = 3
   };
   ms.AppendEntity(dbPt);
   t.AddNewlyCreatedDBObject(dbPt, true);
   t.Commit();

  }
 }

Test sample Drawing

SampleDrawing

How to Check if XREF Edit In Place–Is Saved or Discarded

By Madhukar Moogala

When user edit external reference in place, there is no way to get to know if user had saved the changes or discarded.

If your application would like to capture the user intent, for example.

if (e.GlobalCommandName == /*MSG0*/"REFCLOSE")
{

if (save){
//logic 1
}
if(discard){
//logic 2
}


}

This post will show one way to find out, if Xref is saved or discarded

class XrefCheckEditor;
XrefCheckEditor* xrefEd = nullptr;
class XrefLongTranReactor;
XrefLongTranReactor* xrefTransRctr = nullptr;

Acad::ErrorStatus getSysVar(const TCHAR* varName, TCHAR* val)
{
	resbuf rb;
	if (acedGetVar(varName, &rb) == RTNORM) {
		assert(rb.restype == RTSTR);
		val = rb.resval.rstring;
		free(rb.resval.rstring);
		return(Acad::eOk);
	}
	else
		return(Acad::eInvalidInput);
}
namespace EditInPlaceXref {
	enum EditInPlaceXrefState
	{
		Discarded,
		Saved
		
	};
	EditInPlaceXrefState XrefState;
	EditInPlaceXrefState Reset() {
		XrefState = Discarded;
		return XrefState;
	}
	
}

class XrefLongTranReactor : public AcApLongTransactionReactor {

	virtual void endCheckIn(AcDbLongTransaction& lt) {
		if (lt.type() == AcDbLongTransaction::kXrefDb)
		{
			//We are good, changes have been Saved.
			EditInPlaceXref::XrefState = EditInPlaceXref::Saved;
		}
	}

};
class XrefCheckEditor : public AcEditorReactor {

	virtual void commandEnded(const TCHAR* cmdStr) {
		if (wcscmp(cmdStr, L"REFCLOSE") == 0)
		{
			
			switch (EditInPlaceXref::XrefState)
			{
			case EditInPlaceXref::Saved:
				acutPrintf(L"\n Modifications 
					   To In External Reference Are Saved");
				EditInPlaceXref::Reset();
				break;
			case EditInPlaceXref::Discarded:
				acutPrintf(L"\n Modifications
					   To In External Reference Are Discarded");
				break;
			default:
				break;
			}

		}
	}
};

void watch() {

	if (xrefEd == nullptr && xrefTransRctr == nullptr) {
		xrefEd = new XrefCheckEditor();
		xrefTransRctr = new XrefLongTranReactor();
	}

	acedEditor->addReactor(xrefEd);
	acapLongTransactionManager->addReactor(xrefTransRctr);
	
}
void unWatch() {
	acedEditor->removeReactor(xrefEd);
	acapLongTransactionManager->removeReactor(xrefTransRctr);
	if (xrefEd != nullptr) {
		delete xrefEd;
		xrefEd = nullptr;
	}
	if (xrefTransRctr != nullptr) {
		delete xrefTransRctr;
		xrefTransRctr = nullptr;
	}
	acutPrintf(_T("Watching Editor Reactor\n"));
}

void checkIfXrefSavedOrDiscarded()
{
	acutPrintf(_T("\nThis function checks
		     if changes made to edit-in place xref are saved or discarded"));
	acutPrintf(_T("\nModifications %s"), 
			EditInPlaceXref::XrefState ? _T("Saved") : _T("Discarded"));
}