topic COM Property Registration in ObjectARX Forum

COM Property Registration

Kyudos — Tue, 20 Jun 2017 03:25:47 GMT

I have my COM Property interfaces for my custom entities in my ARX file and I'm having problems with the registration. We try to register the ARX during installation of our app using regsvr32 - but of course this needs to 'run' the server, which means it needs to resolve all of its dependencies, including the AutoCAD ones.

To get this to work you need to add the AutoCAD installation path(s) to your path environment variable, then run regsvr32 as admin - relatively straightforward to do manually - a little trickier during an install.

(I think unresolved dependencies is also the reason my attempts at internal registration fail)

Another approach would be to script the reg entries, but then we need to get the installation path into there for the InProcServer entries.

Is reg-free COM specification via the manifest file an option? If so, is it enough to just have the entries in the manifest? Can you embed the manifest in that situation?

How do you handle this?

Re: COM Property Registration

Alexander.Rivilis — Tue, 20 Jun 2017 05:49:51 GMT

I use this method for registration, regardless of whether or not the user has administrator rights:

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//- DllRegisterServer - Adds entries to the system registry
//STDAPI DllRegisterServer (void) {
//  //- Registers object, typelib and all interfaces in typelib
//  return (_AtlModule.RegisterServer (TRUE)) ;
//}
typedef void (*OaEnablePerUserTLibRegistration)();
STDAPI DllRegisterServer(void)
{
  HINSTANCE hInstOle32=NULL;
  try
  {
    HRESULT hr = _AtlModule.RegisterServer(TRUE);
    if(FAILED(hr))
    {
      hInstOle32 = LoadLibrary(_T("Oleaut32.dll"));
      if(hInstOle32)
      {
        OaEnablePerUserTLibRegistration lr=(OaEnablePerUserTLibRegistration)GetProcAddress(hInstOle32,("OaEnablePerUserTLibRegistration"));

        if(lr!=NULL)
        {
          lr(); 
          hr = _AtlModule.RegisterServer(TRUE);
          if(SUCCEEDED(hr))
          {
            FreeLibrary(hInstOle32);
            return hr;
          }
        }       
      }   

      HKEY hKCr;
      hr=RegOpenKeyEx(HKEY_CURRENT_USER,_T("Software\\Classes"),0,KEY_READ,&hKCr);
      if(hr!=ERROR_SUCCESS)
      {
        return hr;
      }
      hr = RegOverridePredefKey(HKEY_CLASSES_ROOT,hKCr);
      RegCloseKey(hKCr);
      if(FAILED(hr))
      {
        return hr;
      }   
      hr = _AtlModule.RegisterServer(TRUE);
      RegOverridePredefKey(HKEY_CLASSES_ROOT,NULL);
      hr=S_OK;
    }
    if(hInstOle32)
      FreeLibrary(hInstOle32);
    return hr;
  }
  catch (...)
  {
    if(hInstOle32)
      FreeLibrary(hInstOle32);
    return E_FAIL;
  }
}

Note: The corresponding rgs-file must not contain HKLM sections.

Re: COM Property Registration

Kyudos — Wed, 21 Jun 2017 00:23:40 GMT

Thanks Alexander - it is useful to have this code.

It seems to work fine on Windows 7, but not reliably on Win10 (it's Win10 giving me problems in general!)

I think we'll probably go with a reg file, for predicatability.

Re: COM Property Registration

furqananees2007 — Tue, 25 Feb 2025 17:49:36 GMT

@Kyudos @Alexander.Rivilis @OysteinW

I'm encountering the same issue with registering the COM server. I attempted to use the provided code, but I'm receiving some unusual syntax errors at compile time—even though IntelliSense doesn't highlight any problems. Any guidance on how to resolve these errors would be greatly appreciated.

This is the main C++ file that is automatically generated when creating a COM wrapper project using the ObjectARX Wizard.

#include "StdAfx.h" #if defined(_DEBUG) && !defined(AC_FULL_DEBUG) #error _DEBUG should not be defined except in internal Adesk debug builds #endif #include "resource.h" #include <initguid.h> #include "COMSPPC_i.h" #include "COMSPPC_i.c" #include "acadi_i.c" #include <oleauto.h> #include <windows.h> #include <tchar.h> #include "SPPointCloud.h" // Include your custom entity header #include "SPPointCloudCOM.h" CComModule _Module; BEGIN_OBJECT_MAP(ObjectMap) OBJECT_ENTRY(CLSID_SPPointCloudCOM, CSPPointCloudCOM) // Register your COM class END_OBJECT_MAP() ///////////////////////////////////////////////////////////////////////////// // DLL Entry Point extern "C" BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID /*lpReserved*/) { if (dwReason == DLL_PROCESS_ATTACH) { _Module.Init(ObjectMap, hInstance); DisableThreadLibraryCalls(hInstance); // Check if the DBX module is loaded; if not, load it if (!::acrxAppIsLoaded(_T("SPPointCloud.dbx"))) // Replace with your DBX module name { if (!acrxLoadModule(_T("SPPointCloud.dbx"), false, true)) return FALSE; // This will trigger a DLL_PROCESS_DETACH right away } // Bump the reference count acrxLoadModule(_T("SPPointCloud.dbx"), false, false); } else if (dwReason == DLL_PROCESS_DETACH) { _Module.Term(); // Try to decrease the refcount on the DBX module acrxUnloadModule(_T("SPPointCloud.dbx")); } return TRUE; // ok } ///////////////////////////////////////////////////////////////////////////// // Used to determine whether the DLL can be unloaded by OLE STDAPI DllCanUnloadNow(void) { return (_Module.GetLockCount() == 0) ? S_OK : S_FALSE; } ///////////////////////////////////////////////////////////////////////////// // Returns a class factory to create an object of the requested type STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv) { return _Module.GetClassObject(rclsid, riid, ppv); } ///////////////////////////////////////////////////////////////////////////// // DllRegisterServer - Adds entries to the system registry typedef void (*OaEnablePerUserTLibRegistration)(); STDAPI DllRegisterServer(void) { HINSTANCE hInstOle32 = NULL; try { HRESULT hr = _Module.RegisterServer(TRUE); if (FAILED(hr)) { hInstOle32 = LoadLibrary(_T("Oleaut32.dll")); if (hInstOle32) { OaEnablePerUserTLibRegistration lr = (OaEnablePerUserTLibRegistration)GetProcAddress(hInstOle32, ("OaEnablePerUserTLibRegistration")); if (lr != NULL) { lr(); hr = _Module.RegisterServer(TRUE); if (SUCCEEDED(hr)) { FreeLibrary(hInstOle32); return hr; } } } HKEY hKCr; hr = RegOpenKeyEx(HKEY_CURRENT_USER, _T("Software\\Classes"), 0, KEY_READ, &hKCr); if (hr != ERROR_SUCCESS) { return hr; } hr = RegOverridePredefKey(HKEY_CLASSES_ROOT, hKCr); RegCloseKey(hKCr); if (FAILED(hr)) { return hr; } hr = _Module.RegisterServer(TRUE); RegOverridePredefKey(HKEY_CLASSES_ROOT, NULL); hr = S_OK; } if (hInstOle32) FreeLibrary(hInstOle32); return hr; } catch (...) { if (hInstOle32) FreeLibrary(hInstOle32); return E_FAIL; } } ///////////////////////////////////////////////////////////////////////////// // DllUnregisterServer - Removes entries from the system registry STDAPI DllUnregisterServer(void) { _Module.UnregisterServer(); return S_OK; }

Re: COM Property Registration

Kyudos — Tue, 25 Feb 2025 20:15:57 GMT

Ultimately we created self-registering COM classes using RGS files in the resources. Based on this method by Michael Geddes:

https://www.codeproject.com/Articles/6319/Registry-Map-for-RGS-files

And then simply calling DllRegisterServer in DllMain

Re: COM Property Registration

Kyudos — Tue, 25 Feb 2025 20:37:18 GMT

To expand a bit more. Our module is an ATL::CAtlMfcModule that looks like this:

//------------------------------------------------------------------------------ class OurModule : public ATL::CAtlMfcModule //------------------------------------------------------------------------------ { public: DECLARE_LIBID(APPLIBID); #if defined (_M_X64) DECLARE_REGISTRY_APPID_RESOURCEID(IDR_A64_REG, "OUR ACAD 64bit CLSID"); #else DECLARE_REGISTRY_APPID_RESOURCEID(IDR_A32_REG, "OUR ACAD 32bit CLSID"); #endif };

The IDRs are resource IDs for the RGS file in a "REGISTRY" section of the resources.

We also needed this in our app class:

// DllCanUnloadNow - Allows COM to unload DLL #if !defined(_WIN32_WCE) && !defined(_AMD64_) && !defined(_IA64_) #pragma comment(linker, "/EXPORT:DllCanUnloadNow=_DllCanUnloadNow@0,PRIVATE") #pragma comment(linker, "/EXPORT:DllGetClassObject=_DllGetClassObject@12,PRIVATE") #pragma comment(linker, "/EXPORT:DllRegisterServer=_DllRegisterServer@0,PRIVATE") #pragma comment(linker, "/EXPORT:DllUnregisterServer=_DllUnregisterServer@0,PRIVATE") #else #if defined(_X86_) || defined(_SHX_) #pragma comment(linker, "/EXPORT:DllCanUnloadNow=_DllCanUnloadNow,PRIVATE") #pragma comment(linker, "/EXPORT:DllGetClassObject=_DllGetClassObject,PRIVATE") #pragma comment(linker, "/EXPORT:DllRegisterServer=_DllRegisterServer,PRIVATE") #pragma comment(linker, "/EXPORT:DllUnregisterServer=_DllUnregisterServer,PRIVATE") #else #pragma comment(linker, "/EXPORT:DllCanUnloadNow,PRIVATE") #pragma comment(linker, "/EXPORT:DllGetClassObject,PRIVATE") #pragma comment(linker, "/EXPORT:DllRegisterServer,PRIVATE") #pragma comment(linker, "/EXPORT:DllUnregisterServer,PRIVATE") #endif // (_X86_)||(_SHX_) #endif // !_WIN32_WCE && !_AMD64_ && !_IA64_

And our registration functions look like this:

extern OurModule _AtlModule; // <-- extern this in the .h file OurModule _AtlModule; //------------------------------------------------------------------------------ STDAPI DllCanUnloadNow() //------------------------------------------------------------------------------ { if (_AtlModule.GetLockCount() > 0) { return S_FALSE; } return S_OK; } //------------------------------------------------------------------------------ STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv) //------------------------------------------------------------------------------ { // DllGetClassObject - Returns class factory if (S_OK == _AtlModule.GetClassObject(rclsid, riid, ppv)) { return S_OK; } return AfxDllGetClassObject(rclsid, riid, ppv); } //typedef void (*OaEnablePerUserTLibRegistration)(); //------------------------------------------------------------------------------ STDAPI DllRegisterServer() //------------------------------------------------------------------------------ { // DllRegisterServer - Adds entries to the system registry //HRESULT hr = ATL::AtlSetPerUserRegistration(true); HRESULT hRes1 = _AtlModule.UpdateRegistryAppId(TRUE); HINSTANCE hInstOle32 = NULL; try { HRESULT hr = _AtlModule.RegisterServer(TRUE); if (FAILED(hr)) { hInstOle32 = LoadLibrary(_T("Oleaut32.dll")); if (hInstOle32 != NULL) { //OaEnablePerUserTLibRegistration lr = (OaEnablePerUserTLibRegistration)GetProcAddress(hInstOle32, ("OaEnablePerUserTLibRegistration")); ULONG (PASCAL *lr)(); (FARPROC&)lr = GetProcAddress(hInstOle32, ("OaEnablePerUserTLibRegistration")); if (lr != NULL) { lr(); hr = _AtlModule.RegisterServer(TRUE); if (SUCCEEDED(hr)) { FreeLibrary(hInstOle32); return hr; } } HKEY hKCr; hr = RegOpenKeyEx(HKEY_CURRENT_USER, _T("Software\\Classes"), 0, KEY_READ, &hKCr); if (hr != ERROR_SUCCESS) { return hr; } hr = RegOverridePredefKey(HKEY_CLASSES_ROOT, hKCr); if (FAILED(hr)) { RegCloseKey(hKCr); return hr; } hr = _AtlModule.RegisterServer(TRUE); RegCloseKey(hKCr); RegOverridePredefKey(HKEY_CLASSES_ROOT, NULL); hr = S_OK; } } if (hInstOle32 != NULL) { FreeLibrary(hInstOle32); } return hr; } catch (...) { if (hInstOle32) { FreeLibrary(hInstOle32); } return E_FAIL; } } //------------------------------------------------------------------------------ STDAPI DllUnregisterServer() //------------------------------------------------------------------------------ { // DllUnregisterServer - Removes entries from the system registry _AtlModule.UpdateRegistryAppId(FALSE); HRESULT hRes2 = _AtlModule.UnregisterServer(TRUE); return hRes2; }