AcDbObjectId OarxEmployeeService::getAppDictionary () {
AcDbDictionary *pNOD =NULL ;
AcDbDictionary *pFirmDict =NULL ;
AcDbDictionary *pAppDict =NULL ;
try {
//----- Get hold of the NOD
ARXOK ( getNOD (pNOD, AcDb::kForRead) ) ;
//----- Get our Firm Dictionary
AcDbObjectId id0 ;
if ( pNOD->getAt (OARX_FIRM_DICT, id0) == Acad::eKeyNotFound ) {
//----- Then create it
pFirmDict =new AcDbDictionary ;
if ( pFirmDict == NULL )
throw Acad::eOutOfMemory ;
ARXOK ( pNOD->upgradeOpen () ) ;
ARXOK ( pNOD->setAt (OARX_FIRM_DICT, pFirmDict, id0) ) ;
} else {
//----- Open the dictionary
ARXOK ( acdbOpenAcDbObject ((AcDbObject *&)pFirmDict, id0, AcDb::kForRead) ) ;
}
//----- Get our App Dictionary
if ( pFirmDict->getAt (OARX_APP_DICT, id0) == Acad::eKeyNotFound ) {
//----- Then create it
pAppDict =new AcDbDictionary ;
if ( pAppDict == NULL )
throw Acad::eOutOfMemory ;
if ( pFirmDict->isWriteEnabled () == false )
ARXOK ( pFirmDict->upgradeOpen () ) ;
ARXOK ( pFirmDict->setAt (OARX_APP_DICT, pAppDict, id0) ) ;
id0 =pAppDict->objectId () ;
}
pNOD->close () ;
pFirmDict->close () ;
pAppDict->close () ;
return (id0) ;
} catch (const Acad::ErrorStatus es) {
if ( pNOD != NULL )
pNOD->cancel () ;
if ( pFirmDict != NULL && pFirmDict->objectId () == AcDbObjectId::kNull )
delete pFirmDict ;
else if ( pFirmDict != NULL )
pFirmDict->cancel () ;
if ( pAppDict != NULL && pAppDict->objectId () == AcDbObjectId::kNull )
delete pAppDict ;
else
pAppDict->cancel () ;
return (AcDbObjectId::kNull) ;
}
}
void ArxDictTool::RegDict( const CString& dictName )
{
// 初始化工作，建立存储词典
AcDbDictionary* pNamedobj;
acdbHostApplicationServices()->workingDatabase()->getNamedObjectsDictionary( pNamedobj, AcDb::kForWrite );
AcDbObject* pObj;
Acad::ErrorStatus es = pNamedobj->getAt( dictName, pObj, AcDb::kForRead );
if( Acad::eOk == es )
{
pObj->close();
}
else if( Acad::eKeyNotFound == es )
{
AcDbDictionary* pDict = new AcDbDictionary();
AcDbObjectId dictId;
if( Acad::eOk != pNamedobj->setAt( dictName, pDict, dictId ) )
{
delete pDict;
}
else
{
pDict->close();
}
}
pNamedobj->close();
}
Acad::ErrorStatus CTwArxDictionary::CreateSubDictionaryID( IN const AcDbObjectId& IdRoot, IN const CString& strKey, OUT AcDbObjectId& IdSubDic, IN AcRxClass* pRxObjType /*= AcDbDictionary::desc() */ ) const
{
if( pRxObjType == NULL ) return Acad::eNullObjectPointer;
Acad::ErrorStatus es = Acad::eOk;
AcDbDictionary* pDicRoot = NULL;
AcDbDatabase* pWdb = acdbCurDwg();
if( IdRoot.isNull() )
es = pWdb->getNamedObjectsDictionary( pDicRoot, AcDb::kForRead );
else
es = acdbOpenObject( pDicRoot, IdRoot, AcDb::kForRead );
if( es != Acad::eOk ) return es;
if( pDicRoot->has(strKey) )
{
pDicRoot->getAt( strKey, IdSubDic );
pDicRoot->close();
return es;
}
pDicRoot->upgradeOpen();
AcDbObject* pObj = (AcDbObject*)pRxObjType->create();
es = pDicRoot->setAt( strKey, pObj, IdSubDic );
pObj->close();
pDicRoot->close();
return es;
}
void
removeEntryFromDict(const char* strDictKey, AcDbDictionary* pParent,
const char* strEmpKey)
{
AcDbObjectId idO;
//see if our dictionary is there
ARXOK(pParent->getAt(strDictKey,idO));
//get it for write
AcDbObject* pO;
ARXOK(actrTransactionManager->getObject(pO,idO,AcDb::kForWrite));
//check if someone has else has created an entry with our name
//that is not a dictionary. This should never happen as long as
//I use the registered developer ID.
AcDbDictionary* pEmployeeDict;
if ((pEmployeeDict=AcDbDictionary::cast(pO))==NULL)
throw Acad::eNotThatKindOfClass;
//check if a record with this key isthere
ARXOK(pEmployeeDict->getAt(strEmpKey,idO));
//get it for write
ARXOK(actrTransactionManager->getObject(pO,idO,AcDb::kForWrite));
//and erase it
ARXOK(pO->erase());
//erase dictionary if it has no more entries
if (pParent->numEntries()==0)
ARXOK(pParent->erase());
}
static ArxXRecordManager* GetXRecordManager( const AcDbObjectId& dictId, const CString& key, bool createNewKey = false )
{
//acutPrintf(_T("\n注册: %s"), dictName);
AcDbDictionary* pDict = GetDictObject( dictId );
if( pDict == 0 ) return 0;
AcDbXrecord* pXrec = 0;
// key不存在或者其它原因
Acad::ErrorStatus es = pDict->getAt( key, ( AcDbObject*& ) pXrec, AcDb::kForWrite );
if( Acad::eOk != es && Acad::eKeyNotFound != es )
{
pDict->close();
return 0;
}
if( Acad::eKeyNotFound == es )
{
if( createNewKey )
{
pXrec = new AcDbXrecord();
AcDbObjectId xrecObjId;
pDict->setAt( key, pXrec, xrecObjId );
}
else
{
pDict->close();
return 0;
}
}
pDict->close();
return new ArxXRecordManager( pXrec );
}
// The listxrecord() functions gets the xrecord associated with the
// key "ASDK_XREC1" and lists out its contents by passing the resbuf
// list to the function printList().
//
void
listXrecord()
{
AcDbObject *pObj;
AcDbXrecord *pXrec;
AcDbObjectId dictObjId;
AcDbDictionary *pDict;
pObj = selectObject(AcDb::kForRead);
if (pObj == NULL) {
return;
}
// Get the object ID of the object's extension dictionary.
//
dictObjId = pObj->extensionDictionary();
pObj->close();
// Open the extension dictionary and get the xrecord
// associated with the key ASDK_XREC1.
//
acdbOpenObject(pDict, dictObjId, AcDb::kForRead);
pDict->getAt("ASDK_XREC1", (AcDbObject*&)pXrec,
AcDb::kForRead);
pDict->close();
// Get the xrecord's data list and then close the xrecord.
//
struct resbuf *pRbList;
pXrec->rbChain(&pRbList);
pXrec->close();
printList(pRbList);
acutRelRb(pRbList);
}
// The list tree function runs through all objects in the ASDK_DICT dictionary,
// follows their ownership trees, and lists out information
// on all objects in the tree.
//
void
listTree()
{
AcDbDictionary *pNamedobj;
AcDbDictionary *pDict;
acdbHostApplicationServices()->workingDatabase()
->getNamedObjectsDictionary(pNamedobj, AcDb::kForWrite);
// Get a pointer to the ASDK_DICT dictionary.
//
if (pNamedobj->getAt(_T("ASDK_DICT"), (AcDbObject*&) pDict,
AcDb::kForRead) == Acad::eKeyNotFound)
{
pNamedobj->close();
return ;
}
pNamedobj->close();
// Run through the entries and list their backpointers.
//
AcDbDictionaryIterator *pDictItr = pDict->newIterator();
for (; !pDictItr->done(); pDictItr->next()) {
printOut(pDictItr->objectId());
}
delete pDictItr;
pDict->close();
}
//-------------------------------------------------------------------------------------------
//
// 功能： 将从AcDbObject派生数据库对象保存到实体的扩展词典中
//
// 作者：Qin H.X.
//
// 日期：200709
//
// 历史：
// 2007.10.08 修改 by Qin H.X.
//
//----------------------------------------------------------------------------------------------
// - CSCH081.AddAttribute command (do not rename)
static void CSCH081AddAttribute(void)
{
AcDbObjectId dictObjId,eId, attId;
AcDbDictionary* pDict;
//选择管道（多义线）
ads_name en;
ads_point pt;
if ( acedEntSel(_T("\n选择管道（多义线）: "), en, pt)!= RTNORM)
{
acutPrintf(_T("\n选择失败，退出: "));
return ;
}
// 打开对象
acdbGetObjectId(eId, en);
AcDbEntity * pEnt;
acdbOpenObject(pEnt, eId, AcDb::kForWrite);
if(!pEnt->isKindOf (AcDbPolyline::desc ()))
{
acutPrintf(_T("\n选择的不是管道（多义线），退出: " ));
return ;
}
// 判断实体的扩展词典是否创建，如果没有则创建
dictObjId = pEnt->extensionDictionary();
if( dictObjId == AcDbObjectId::kNull )
{
pEnt->createExtensionDictionary();
}
// 获取实体的扩展词典
dictObjId = pEnt->extensionDictionary();
pEnt->close();
// 判断词典中的属性是否创建
CPipeAttribute* pAttribute;
acdbOpenObject(pDict, dictObjId, AcDb::kForWrite);
pDict->getAt (_T("属性"),attId);
if(attId!= AcDbObjectId::kNull )//如果已经创建则输出数据
{
acdbOpenObject(pAttribute, attId, AcDb::kForRead);
acutPrintf(_T("\n管径：%4.2f " ),pAttribute->m_dRadius);
acutPrintf(_T("\n壁厚：%4.2f " ),pAttribute->m_dThickness );
acutPrintf(_T("\n埋深：%4.2f " ),pAttribute->m_dDeep );
acutPrintf(_T("\n材质：%s " ),pAttribute->m_cMaterial );
}
else
{
//没有则创建属性
pAttribute = new CPipeAttribute();
pDict->setAt(_T("属性"), pAttribute, attId);
}
//关闭对象
pDict->close();
pAttribute->close();
}
bool ArxDictTool2::findEntry( const CString& key, AcDbObjectId& objId )
{
AcDbDictionary* pDict = GetDictObject( m_dictId );
if( pDict == 0 ) return false;
bool ret = ( Acad::eOk == pDict->getAt( key, objId ) );
//acutPrintf(_T("\nArxDitToll->Ret:%s"),ret?_T("Y"):_T("N"));
pDict->close();
return ret;
}
//-----------------------------------------------------------------------------
//----- This is the AcRxService class Implementation
Adesk::Boolean OarxEmployeeService::isEmployeeExist (int id) {
AcDbDictionary *pNOD =NULL ;
AcDbDictionary *pFirmDict =NULL ;
AcDbDictionary *pAppDict =NULL ;
try {
//----- Get hold of the NOD
ARXOK ( getNOD (pNOD, AcDb::kForRead) ) ;
//----- Get our Firm Dictionary
AcDbObjectId id0 ;
ARXOK ( pNOD->getAt (OARX_FIRM_DICT, id0) ) ;
ARXOK ( acdbOpenAcDbObject ((AcDbObject *&)pFirmDict, id0, AcDb::kForRead) ) ;
//----- Get our App Dictionary
ARXOK ( pFirmDict->getAt (OARX_APP_DICT, id0) ) ;
ARXOK ( acdbOpenAcDbObject ((AcDbObject *&)pAppDict, id0, AcDb::kForRead) ) ;
//----- Check if that entry already exist
char buffer [33] ;
sprintf (buffer, "%d", id) ;
Adesk::Boolean bRet =pAppDict->has (buffer) ;
//----- Normally we should have open the associated XRecord, and check the validity of
//----- the SoftPointerId which is supposed to point to an OarxEmployee entity... But
//----- to simplify the sample we stop checking here!
pNOD->close () ;
pFirmDict->close () ;
pAppDict->close () ;
return (bRet) ;
} catch (const Acad::ErrorStatus es) {
if ( pNOD != NULL )
pNOD->cancel () ;
if ( pFirmDict != NULL )
pFirmDict->cancel () ;
if ( pAppDict != NULL )
pAppDict->cancel () ;
return (Adesk::kFalse) ;
}
}
AcDbObjectId ArxDictTool::GetDict( const CString& dictName )
{
AcDbDictionary* pNameObjDict;
if( Acad::eOk != acdbHostApplicationServices()->workingDatabase()->getNamedObjectsDictionary( pNameObjDict, AcDb::kForRead ) )
{
return AcDbObjectId::kNull;
}
AcDbObjectId dictId;
Acad::ErrorStatus es = pNameObjDict->getAt( dictName, dictId );
pNameObjDict->close();
return dictId;
}
void
addDictAndEntry(const char* strDictKey, AcDbDictionary* pParent,
const char* strEmpKey, AcDbObject* pEmployee)
{
AcDbObjectId idO;
AcDbDictionary* pEmployeeDict;
//unerase the dictionary if it was erased
if (pParent->isErased())
ARXOK(pParent->erase(Adesk::kFalse));
//see if our dictionary is already there
if (pParent->getAt(strDictKey,idO)==Acad::eKeyNotFound){
//create it if not
if ((pEmployeeDict=new AcDbDictionary)==NULL)
throw Acad::eOutOfMemory;
Acad::ErrorStatus es;
pParent->upgradeOpen();
if ((es=pParent->setAt(strDictKey,pEmployeeDict,idO))!=Acad::eOk){
//make sure that we don't leak memory
//a smart pointer would come handy but let's not confuse
//everyone quite yet
delete pEmployeeDict;
throw es;
}
//this will ensure that the newly added object is properly
//committed to the db when the transaction ends
actrTransactionManager->addNewlyCreatedDBRObject(pEmployeeDict);
} else {
//get it for write if it is already there
AcDbObject* pO;
ARXOK(actrTransactionManager->getObject(pO,idO,AcDb::kForWrite));
//check if someone has else has created an entry with our name
//that is not a dictionary. This should never happen as long as
//I use the registered developer ID.
if ((pEmployeeDict=AcDbDictionary::cast(pO))==NULL)
throw Acad::eNotThatKindOfClass;
}
//check if a record with this key is already there
Acad::ErrorStatus es;
if ((es=pEmployeeDict->getAt(strEmpKey,idO))==Acad::eOk)
throw Acad::eAlreadyInDb;
if (es!=Acad::eKeyNotFound)
throw es;
ARXOK(pEmployeeDict->setAt(strEmpKey,pEmployee,idO));
//this will ensure that the newly added object is properly
//committed to the db when the transaction ends
actrTransactionManager->addNewlyCreatedDBRObject(pEmployee);
}
AcDbObjectId
ArxDbgUiTdcPersistentReactors::getPersistentEntReactor(AcDbDatabase* db, bool createIfNotFound)
{
static LPCTSTR dictEntryName = _T("ARXDBG_PERSISTENT_ENT_REACTOR");
AcDbObjectId prId;
AcDbDictionary* prDict;
// first see if its already there without "disturbing" anyone by opening them
// for write.
prDict = ArxDbgUtils::openDictionaryForRead(m_dictName, db);
if (prDict != NULL) {
if (prDict->getAt(dictEntryName, prId) == Acad::eOk) {
prDict->close();
return prId;
}
prDict->close();
}
// couldn't find it, bail if we aren't supposed to create it.
if (createIfNotFound == false)
return AcDbObjectId::kNull;
// not here yet, so make an entry
prDict = ArxDbgUtils::openDictionaryForWrite(m_dictName, true, db);
if (prDict == NULL)
return AcDbObjectId::kNull;
Acad::ErrorStatus es;
ArxDbgPersistentEntReactor* pr = new ArxDbgPersistentEntReactor;
es = prDict->setAt(dictEntryName, pr, prId);
if (es != Acad::eOk) {
ArxDbgUtils::rxErrorMsg(es);
ArxDbgUtils::alertBox(_T("ERROR: Could not add entry to dictionary."));
delete pr;
prDict->close();
return AcDbObjectId::kNull;
}
else {
pr->close();
prDict->close();
return prId;
}
}
Acad::ErrorStatus CTwArxDictionary::GetSubDictionaryID( IN const AcDbObjectId& IdRoot, IN const CString& strKey, AcDbObjectId& IdSub, AcDbDatabase* pCurDB ) const
{
Acad::ErrorStatus es = Acad::eOk;
AcDbDictionary* pDicRoot = NULL;
AcDbDatabase* pWdb = pCurDB;
if( pWdb == NULL )
pWdb = acdbCurDwg();
if( IdRoot.isNull() )
es = pWdb->getNamedObjectsDictionary( pDicRoot, AcDb::kForRead );
else
es = acdbOpenObject( pDicRoot, IdRoot, AcDb::kForRead );
if( pDicRoot == NULL ) return es;
pDicRoot->close();
es = pDicRoot->getAt( strKey, IdSub );
return es;
}
AcDbObjectId
ArxDbgDbAdeskLogoStyle::getStandardStyle(AcDbDatabase* db, bool makeIfNotThere)
{
Acad::ErrorStatus es;
AcDbObjectId styleId;
AcDbDictionary* dict;
const char* standardStrPtr = acdbGetReservedString(AcDb::kStandard, false);
ASSERT(standardStrPtr != NULL);
dict = ArxDbgUtils::openDictionaryForRead(m_dictName, db);
if (dict) {
es = dict->getAt(standardStrPtr, styleId);
dict->close();
if (es == Acad::eOk)
return styleId;
if (makeIfNotThere == false)
return AcDbObjectId::kNull;
}
// wasn't already there, so we need to make it
dict = ArxDbgUtils::openDictionaryForWrite(m_dictName, true, db);
if (dict) {
ArxDbgDbAdeskLogoStyle* newRec = new ArxDbgDbAdeskLogoStyle;
es = dict->setAt(standardStrPtr, newRec, styleId);
dict->close();
if (es == Acad::eOk) {
newRec->close();
return styleId;
}
else {
acutPrintf("\nERROR: Could not add new ArxDbgDbAdeskLogoStyle (%s)", ArxDbgUtils::rxErrorStr(es));
delete newRec;
}
}
return AcDbObjectId::kNull;
}
void listEmpsCommand()
{
//this cannot really happen but...
if (acdbHostApplicationServices()->workingDatabase()==NULL)
return;
AcDbDictionaryIterator* pIter=NULL;
try
{
//start transaction for the db operations in this command
actrTransactionManager->startTransaction();
//get the named object dictionary
AcDbDictionary* pNOD;
ARXOK(getNOD(pNOD,AcDb::kForRead));
//see if our dictionary is there
AcDbObjectId idO;
ARXOK(pNOD->getAt(DICT,idO));
//get it for write
AcDbObject* pO;
ARXOK(actrTransactionManager->getObject(pO,idO,AcDb::kForWrite));
//check if someone has else has created an entry with our name
//that is not a dictionary. This should never happen as long as
//I use the registered developer ID.
AcDbDictionary* pEmployeeDict=NULL;
if ((pEmployeeDict=AcDbDictionary::cast(pO))==NULL)
throw Acad::eNotThatKindOfClass;
if ((pIter = pEmployeeDict->newIterator(AcRx::kDictCollated))!=NULL){
for (;!pIter->done();pIter->next()){
//get the object
ARXOK(actrTransactionManager->getObject(pO,pIter->objectId(),AcDb::kForRead));
//check if it is the right one
EmployeeEntry* pEmployeeEntry;
if ((pEmployeeEntry=EmployeeEntry::cast(pO))==NULL)
throw Acad::eNotThatKindOfClass;
//get the corresponding EmployeeDetail object
ARXOK(actrTransactionManager->getObject(pO,pEmployeeEntry->employee(),AcDb::kForRead));
EmployeeDetails* pEmployeeDetails;
if ((pEmployeeDetails=EmployeeDetails::cast(pO))==NULL)
throw Acad::eNotThatKindOfClass;
//print the details now
acutPrintf("*Employee's ID:%d\n",pEmployeeDetails->ID());
acutPrintf("*Employee's cube number:%d\n",pEmployeeDetails->cubeNumber());
acutPrintf("*Employee's first name:%s\n",pEmployeeDetails->firstName());
acutPrintf("*Employee's last name:%s\n",pEmployeeDetails->lastName());
//this will ease memory burden when implemented
ARXOK(actrTransactionManager->markObjectPageable(pO));
}
//shouldn't forget this
delete pIter;
pIter=NULL;
}
actrTransactionManager->endTransaction();
}
catch (const Acad::ErrorStatus es)
{
if (pIter!=NULL)
delete pIter;
//abort, rollback all db operations
actrTransactionManager->abortTransaction();
//check if the user has cancelled us, then we don't report
//anything
if (es!=Acad::eUserBreak)
acutPrintf("***Error: %s\n",acadErrorStatusText(es));
}
}
void generateInventarTable(std::map<std::wstring, AcGePoint3d>& m_points, double textHeight)
{
Acad::ErrorStatus es;
AcGePoint3d insertionPoint;
AcDbObjectId objectID;
AcDbTable* pTable = nullptr;
AcDbDictionary* pDic = nullptr;
AcDbBlockTable* pBT = nullptr;
AcDbBlockTableRecord* pBTR = nullptr;
AcDbDatabase*pDb = nullptr;
u_int nrRows = m_points.size() + 2;
double headerHeight = textHeight + ((textHeight * HEADERPERCENT) / 100);
double titleHeight = textHeight + ((textHeight * TITLEPERCENT) / 100);
double nrpctWidth = 0.0;
int ret = acedGetPoint(NULL, _T("\nSelecteaza punctul de insertie al tabelului "), asDblArray(insertionPoint));
AcDbObjectId textID = Utils::NewTextStyle(_T("TableStyle"), titleHeight);
pDb = acdbHostApplicationServices()->workingDatabase();
pBTR = new AcDbBlockTableRecord;
pDb->getSymbolTable(pBT, AcDb::kForRead);
pBT->getAt(ACDB_MODEL_SPACE, pBTR, AcDb::kForWrite);
pBT->close();
es = pDb->getTableStyleDictionary(pDic, AcDb::kForWrite);
es = pDic->getAt(_T("Standard"), objectID);
es = pDic->close();
pTable = new AcDbTable;
pTable->setTableStyle(objectID);
pTable->setSize(nrRows, NUM_COL);
pTable->setAlignment(AcDb::kMiddleCenter);
pTable->setTextHeight( titleHeight,AcDb::kTitleRow);
pTable->setTextHeight(headerHeight, AcDb::kHeaderRow);
pTable->setTextHeight(textHeight, AcDb::kDataRow);
//pTable->setTextStyle(objectID);
pTable->setTextStyle(0, 0, textID);
pTable->setTextString(0, 0, _T("Inventar de coordonate"));
double tableWidth = Utils::GetTextWidth(_T("Inventar@de@coordonate"), _T("TableStyle"));
pTable->setWidth(tableWidth + (tableWidth * 15) / 100);
pTable->setTextString(1, 0, _T("Nr.\npct."));
pTable->setTextStyle(1,0, textID);
nrpctWidth = Utils::GetTextWidth(_T("NRPCT"), _T("TableStyle"));
pTable->setColumnWidth(0,nrpctWidth);
pTable->setTextStyle(1, 1, textID);
pTable->setTextString(1, 1, _T("X[m]"));
pTable->setTextStyle(1, 2, textID);
pTable->setTextString(1, 2, _T("Y[m]"));
std::map<std::wstring, AcGePoint3d>::iterator it = m_points.begin();
for (u_int row = 0; row < nrRows; row++)
{
//double tempWidth = Utils::GetTextWidth(Utils::int_To_wstring(row + 1).c_str(),_T("TableStyle"));
//if (tempWidth > nrpctWidth)
//{
// nrpctWidth = tempWidth;
// pTable->setColumnWidth(0, nrpctWidth);
//}
pTable->setTextStyle(row + 2, 0, textID);
pTable->setTextString(row + 2, 0, Utils::int_To_wstring(row+1).c_str()); //nr. curent
pTable->setTextStyle(row + 2, 1, textID);
pTable->setTextString(row + 2, 1, Utils::real_To_wstring(it->second.y).c_str()); // valoare X
pTable->setTextStyle(row + 2, 2, textID);
pTable->setTextString(row + 2, 2, Utils::real_To_wstring(it->second.x).c_str()); // valoare Y
it++;
}
pTable->generateLayout();
pTable->setPosition(insertionPoint);
pBTR->appendAcDbEntity(pTable);
pBTR->close();
pTable->close();
}
void removeEmpCommand()
{
//this cannot really happen but...
if (acdbHostApplicationServices()->workingDatabase()==NULL)
return;
try
{
//start transaction for the db operations in this command
actrTransactionManager->startTransaction();
//get you extension dictionary
AcDbDictionary* pExtDict = NULL;
getExtDictOfObject(pExtDict);
//get the id from the EmployeeDetails object
//see if our dictionary is there
AcDbObjectId idO;
ARXOK(pExtDict->getAt(DICT,idO));
//get it for write
AcDbObject* pO;
ARXOK(actrTransactionManager->getObject(pO,idO,AcDb::kForWrite));
//check if someone has else has created an entry with our name
//that is not a dictionary. This should never happen as long as
//I use the registered developer ID.
AcDbDictionary* pEmployeeDict=NULL;
if ((pEmployeeDict=AcDbDictionary::cast(pO))==NULL)
throw Acad::eNotThatKindOfClass;
//check if a record with this key is there
ARXOK(pEmployeeDict->getAt(DETAILS,idO));
//get it for write
ARXOK(actrTransactionManager->getObject(pO,idO,AcDb::kForWrite));
EmployeeDetails* pEmployeeDetails;
if ((pEmployeeDetails=EmployeeDetails::cast(pO))==NULL)
throw Acad::eNotThatKindOfClass;
//create string key from the employee id
char strID[33];
sprintf(strID,"%d",pEmployeeDetails->ID());
//and then erase it
ARXOK(pO->erase());
//get hold of the NOD
AcDbDictionary* pNOD;
ARXOK(getNOD(pNOD,AcDb::kForWrite));
//remove the EmployeeEntry from NOD
removeEntryFromDict(DICT,pNOD,strID);
actrTransactionManager->endTransaction();
}
catch (const Acad::ErrorStatus es)
{
//abort, rollback all db operations
actrTransactionManager->abortTransaction();
//check if the user has cancelled us, then we don't report
//anything
if (es!=Acad::eUserBreak)
acutPrintf("***Error: %s\n",acadErrorStatusText(es));
}
}
void
createObjs()
{
AcDbObjectId objIdA, objIdB, objIdC;
AcDbDictionary *pNamedobj;
AcDbDictionary *pDict = NULL;
AcDbDatabase *pCurDwg = acdbHostApplicationServices()->workingDatabase();
// Create object C with a dummy integer data value of 3.
//
AsdkOwnerDemo *pObjC = new AsdkOwnerDemo(3);
// Append object C to database without setting an owner.
//
pCurDwg->addAcDbObject(objIdC, pObjC);
pObjC->close();
// Create object B with a dummy integer data value of 2.
//
AsdkOwnerDemo *pObjB = new AsdkOwnerDemo(2);
// Append object B to the database without setting an owner.
//
pCurDwg->addAcDbObject(objIdB, pObjB);
// Now set up ownership for object C. The
// AsdkOwnerDemo::setIdData() function takes the
// objectId parameter and copies it into the
// AcDbHardOwnershipId data member. This places the
// object ID in a position to be filed out/in via the
// dwgInFields/dwgOutFields/dxfInFields/dxfOutFields
// member functions. This constitutes primary
// "ownership." The AsdkOwnerDemo::setIdData() function
// also calls each owned object's setOwnerId() member
// function to set the backpointer and establish the
// full two-way ownership link.
//
pObjB->setIdData(objIdC);
pObjB->close();
// Create object A with a dummy integer data value of 1.
//
AsdkOwnerDemo *pObjA = new AsdkOwnerDemo(1);
// Next, add objA to a dictionary in the named object
// dictionary. This will establish ownership for objA,
// set the ownership backlink, and add it to the
// database.
//
pCurDwg->getNamedObjectsDictionary(pNamedobj,
AcDb::kForWrite);
// Get a pointer to the ASDK_DICT dictionary. If it
// doesn't exist, then create it and add it to the
// named object dictionary.
//
if (pNamedobj->getAt("ASDK_DICT", (AcDbObject*&) pDict,
AcDb::kForWrite) == Acad::eKeyNotFound)
{
pDict = new AcDbDictionary;
AcDbObjectId DictId;
pNamedobj->setAt("ASDK_DICT", pDict, DictId);
}
pNamedobj->close();
// add object A to the ASDK_DICT dictionary
//
pDict->setAt("OBJA", pObjA, objIdA);
pDict->close();
// Now set up ownership for object B.
//
pObjA->setIdData(objIdB);
pObjA->close();
}
// AsdkNODEdReactor is derived from AcEditorReactor
//
void
AsdkNODEdReactor::beginDeepCloneXlation(
AcDbIdMapping& idMap,
Acad::ErrorStatus* pRetStat)
{
Acad::ErrorStatus es;
AcDbObjectId dictId;
if ( idMap.deepCloneContext() != AcDb::kDcWblock
&& idMap.deepCloneContext() != AcDb::kDcInsert)
return;
// Get the "from" and "to" databases.
//
AcDbDatabase *pFrom, *pTo;
idMap.origDb(pFrom);
idMap.destDb(pTo);
// See if the "from" database has our dictionary, and
// open it. If it doesn't have one, we are done.
//
AcDbDictionary *pSrcNamedObjDict;
pFrom->getNamedObjectsDictionary(pSrcNamedObjDict,
AcDb::kForRead);
es = pSrcNamedObjDict->getAt(kpDictionary, dictId);
pSrcNamedObjDict->close();
if (es == Acad::eKeyNotFound)
return;
AcDbDictionary *pSrcDict;
acdbOpenObject(pSrcDict, dictId, AcDb::kForRead);
AcDbObject *pClone;
switch (idMap.deepCloneContext()) {
case AcDb::kDcWblock:
// WBLOCK clones all, or part of a drawing into a
// newly created drawing. This means that the
// NamedObject Dictionary is always cloned, and
// its AcDbObjectIds are in flux. Therefore, you
// cannot use getAt() or setAt() on the dictionary
// in the new database. This is because the
// cloned dictionary references all refer to the
// original objects. During Deep Clone translation,
// all cloned entries will be translated to the
// new objects, and entries not cloned will be
// "removed" by getting "translated" to NULL.
//
// The cloning of entries in our own dictionary are
// not handled here. If all are to be cloned, then
// call setTreatElementsAsHard(Adesk::kTrue) on the
// dictionary. Otherwise, only those entries which
// are refered to by hard references in other
// wblocked objects, will have been cloned via
// those references.
// In this example, we will always write out all of
// the records. Since TreatElementsAsHard is not
// currently persistent, we reset it here each time.
//
pSrcDict->upgradeOpen();
pSrcDict->setTreatElementsAsHard(Adesk::kTrue);
pClone = NULL;
pSrcDict->wblockClone(pTo, pClone, idMap,
Adesk::kFalse);
if (pClone != NULL)
pClone->close();
break;
case AcDb::kDcInsert:
// In INSERT, an entire drawing is cloned, and
// "merged" into a pre-existing drawing. This
// means that the destination drawing may already
// have our dictionary - in which case we have to
// merge our entries into the destination
// dictionary. So, first we must find out if
// the destination NamedObjects dictionary has
// our dictionary.
//
AcDbDictionary *pDestNamedDict;
pTo->getNamedObjectsDictionary(pDestNamedDict,
AcDb::kForWrite);
// Since INSERT does not clone the destination
// NamedObjects dictionary, we can use getAt()
// on it.
//
es = pDestNamedDict->getAt(kpDictionary, dictId);
// If our dictionary does not yet exist in the
// NamedObjects dictionary, which is not itself
// cloned, we have to both clone and add our
// dictionary to it. Since dictionary entries are
// ownership references, all of our entries will
// also be cloned at this point, so we are done.
//
if (es == Acad::eKeyNotFound) {
pClone = NULL;
pSrcDict->deepClone(pDestNamedDict,
pClone, idMap);
// Unless we have overridden the deepClone
// of our dictionary, we should expect it to
// always be cloned here.
//
if (pClone == NULL) {
*pRetStat = Acad::eNullObjectId;
break;
}
pDestNamedDict->setAt(kpDictionary,
pClone, dictId);
pDestNamedDict->close();
pClone->close();
break;
}
pDestNamedDict->close();
// Our dictionary already exists in the destination
// database, so now we must "merge" the entries
// into it. Since we have not cloned our
// destination dictionary, its objectIds are not in
// flux, and we can use getAt() and setAt() on it.
//
AcDbDictionary *pDestDict;
acdbOpenObject(pDestDict, dictId, AcDb::kForWrite);
AcDbObject *pObj, *pObjClone;
AcDbDictionaryIterator* pIter;
pIter = pSrcDict->newIterator();
for (; !pIter->done(); pIter->next()) {
const char *pName = pIter->name();
pIter->getObject(pObj, AcDb::kForRead);
// If the dictionary contains any references
// and/or other objects have references to it,
// you must either use deepClone() or put the
// idPairs into the idMap here, so that they
// will be in the map for translation.
//
pObjClone = NULL;
pObj->deepClone(pDestDict, pObjClone, idMap);
// INSERT usually uses a method of cloning
// called CheapClone, where it "moves" objects
// into the destination database instead of
// actually cloning them. When this happens,
// pObj and pObjClone are pointers to the
// same object. We only want to close pObj
// here if it really is a different object.
//
if (pObj != pObjClone)
pObj->close();
if (pObjClone == NULL)
continue;
// If the name already exists in our
// destination dictionary, it must be changed
// to something unique. In this example, the
// name is changed to an annonymous entry.
// The setAt() method will automatically append
// a unique identifier to each name beginning
// with "*". It will become something like,
// "*S04".
//
if ( pDestDict->getAt(pName, dictId)
== Acad::eKeyNotFound)
pDestDict->setAt(pName, pObjClone, dictId);
else
pDestDict->setAt("*S", pObjClone, dictId);
pObjClone->close();
}
delete pIter;
pDestDict->close();
break;
default:
break;
}
pSrcDict->close();
}