dbutilities.cpp

能在MDT5/6环境下对已经存在地曲面进行全部和局部区域展开

	assert( !(whichDict==NULL || *whichDict=='\0') );

	Acad::ErrorStatus stat;
	char *storeName;
	int name_len;
	name_len = strlen(entryname);
	if((name_len>NOD_OBJ_NAME_LEN) || (strlen(whichDict)==0)) {
		stat = Acad::eInvalidInput;
		return stat;
	}
	if(entryname != NULL)
	{
		storeName = new char[name_len];
		strcpy(storeName, entryname);
		replaceChars(storeName, ' ', '_');
//		storeName = strupr(storeName);
	}
	
	if(pTargetDb==NULL)
		pTargetDb = acdbHostApplicationServices()->workingDatabase();
	
	AcDbDictionary *pNamedObj = NULL;
	stat = pTargetDb->getNamedObjectsDictionary(pNamedObj, AcDb::kForWrite);
	if(stat != Acad::eOk) {
		return stat;
	}
	
	AcDbDictionary *pDict = NULL;
	if(pNamedObj->getAt(whichDict, (AcDbObject *&) pDict, AcDb::kForWrite) == Acad::eKeyNotFound) {
		pDict = new AcDbDictionary;
		AcDbObjectId dictId;
		pNamedObj->setAt(whichDict, pDict, dictId);
	}
	pNamedObj->close();
		
	AcDbObjectId eId;
	
	if(pDict->getAt(storeName, eId) == Acad::eOk) {
		// storeName object already exists in the dictionary
		if(!bOverideIfnameExists) {
			stat = Acad::eAlreadyInDb;
		} else {
			pDict->remove(storeName);
			stat = pDict->setAt(storeName, pObj, eId);
		}
	}
	else
		stat = pDict->setAt(storeName, pObj, eId);			
	
	pDict->close();
	delete [] storeName;
	
	return stat;		
}

Acad::ErrorStatus 
postToNODCompanyDictionary(AcDbObject *pObj, 
						   const char *entryname,
						   const char *whichDict,
						   bool bOverideIfnameExists)
{
	return postToNODCompanyDictionary(NULL,pObj,entryname,whichDict,bOverideIfnameExists);
}


//--------------------------------------------------------------------------------
Acad::ErrorStatus 
postToDictionary(AcDbObject *pObj, 
				 const char *entryname,
				 AcDbDictionary *pDict,
				 bool bOverideIfnameExists)
{
	assert( pObj != NULL );
	assert( pDict != NULL );
	assert( !(entryname==NULL || *entryname=='\0') );

	Acad::ErrorStatus stat;
	char *storeName;
	int name_len;
	name_len = strlen(entryname);
	if(name_len>NOD_OBJ_NAME_LEN) {
		stat = Acad::eInvalidInput;
		return stat;
	}
	if(entryname != NULL)
	{
		storeName = new char[name_len];
		strcpy(storeName, entryname);
		replaceChars(storeName, ' ', '_');
	}
	
	AcDbObjectId eId;

	if(pDict->getAt(storeName, eId) == Acad::eOk) {
		// storeName object already exists in the dictionary
		if(!bOverideIfnameExists) {
			stat = Acad::eAlreadyInDb;
		} else {
			if(pDict->isReadEnabled()) pDict->upgradeOpen();
			pDict->remove(storeName);
			stat = pDict->setAt(storeName, pObj, eId);
		}
	}
	else
		stat = pDict->setAt(storeName, pObj, eId);			

	delete [] storeName;
	
	return stat;		
}


Acad::ErrorStatus 
postToNOD(AcDbDatabase *pTargetDb,
		  AcDbObject *pObj, 
		  const char *entryname,
		  bool bOverideIfnameExists)
{
	assert( pObj != NULL );
	assert( !(entryname==NULL || *entryname=='\0') );

	Acad::ErrorStatus stat;
	char *storeName;
	int name_len;
	name_len = strlen(entryname);
	if((name_len>NOD_OBJ_NAME_LEN)) {
		stat = Acad::eInvalidInput;
		return stat;
	}
	if(entryname != NULL)
	{
		storeName = new char[name_len];
		strcpy(storeName, entryname);
		replaceChars(storeName, ' ', '_');
	}
	
	if(pTargetDb==NULL)
		pTargetDb = acdbHostApplicationServices()->workingDatabase();
	
	AcDbDictionary *pNOD = NULL;
	pTargetDb->getNamedObjectsDictionary(pNOD, AcDb::kForWrite);
	
	AcDbObjectId eId;
	if(pNOD->getAt(storeName, eId) == Acad::eOk) {
		// storeName object already exists in the dictionary
		if(!bOverideIfnameExists) {
			stat = Acad::eAlreadyInDb;
		} else {
			pNOD->remove(storeName);
			stat = pNOD->setAt(storeName, pObj, eId);
		}
	}
	else
		stat = pNOD->setAt(storeName, pObj, eId);			
	
	pNOD->close();
	delete [] storeName;
	
	return stat;		
}

Acad::ErrorStatus 
postToNOD(AcDbObject *pObj, const char *entryname,bool bOverideIfnameExists)
{
	return postToNOD(NULL,pObj,entryname,bOverideIfnameExists);
}

Acad::ErrorStatus 
deleteInNODCompanyDictionary(AcDbDatabase *pTargetDb, 
							 const char *entryname,
							 const char *whichDict)
{
	assert( !(entryname==NULL || *entryname=='\0') );
	assert( !(whichDict==NULL || *whichDict=='\0') );

	Acad::ErrorStatus stat;
	char *storeName;
	int name_len;
	name_len = strlen(entryname);
	if((name_len>NOD_OBJ_NAME_LEN) || (strlen(whichDict)==0)) {
		stat = Acad::eInvalidInput;
		return stat;
	}
	if(entryname != NULL)
	{
		storeName = new char[name_len];
		strcpy(storeName, entryname);
		replaceChars(storeName, ' ', '_');
//		storeName = strupr(storeName);
	}

	AcDbObject *pObj;
	
	if(pTargetDb==NULL)
		pTargetDb = acdbHostApplicationServices()->workingDatabase();
	
	AcDbDictionary *pNamedObj = NULL;
	stat = pTargetDb->getNamedObjectsDictionary(pNamedObj, AcDb::kForWrite);
	if(stat != Acad::eOk) {
		return stat;
	}
	
	AcDbDictionary *pDict = NULL;
	if(pNamedObj->getAt(whichDict, (AcDbObject *&) pDict, AcDb::kForWrite) == Acad::eKeyNotFound) {
		pDict = new AcDbDictionary;
		AcDbObjectId dictId;
		pNamedObj->setAt(whichDict, pDict, dictId);
	}
	pNamedObj->close();
		
	AcDbObjectId eId;
	
	if(pDict->getAt(storeName, eId) == Acad::eOk) {
		// storeName object already exists in the dictionary
		acdbOpenAcDbObject(pObj, eId, AcDb::kForWrite);  
		
		pDict->remove(storeName);
		
		pObj->erase();
		pObj->close();
		stat = Acad::eOk;
	}
	else {
		stat = Acad::eKeyNotFound;
	}
	

	pDict->close();
	delete [] storeName;
	
	return stat;		
}

Acad::ErrorStatus 
deleteInNODCompanyDictionary(const char *entryname,
							 const char *whichDict)
{
	return deleteInNODCompanyDictionary(NULL,entryname,whichDict);
}


Acad::ErrorStatus 
deleteInNOD(AcDbDatabase *pTargetDb, const char *entryname)
{
	assert( !(entryname==NULL || *entryname=='\0') );

	Acad::ErrorStatus es;

	if(pTargetDb==NULL)
		pTargetDb = acdbHostApplicationServices()->workingDatabase();
	
	AcDbDictionary *pNOD = NULL;
	pTargetDb->getNamedObjectsDictionary(pNOD, AcDb::kForWrite);
			
	AcDbObjectId eId;
	es =  pNOD->getAt(entryname, eId);
	if(es == Acad::eOk) {
		AcDbObject *pObj;
		acdbOpenAcDbObject(pObj, eId, AcDb::kForWrite); 
		AcDbDictionary *pDict;
		pDict = AcDbDictionary::cast(pObj);
		if(pDict) {
			if(pDict->numEntries()) es = Acad::eCannotBeErasedByCaller;
		}
		if(es == Acad::eOk) {
			pNOD->remove(eId);
			if(pObj->isReadEnabled()) pObj->upgradeOpen();
			es = pObj->erase();
		}
		pObj->close();
	}

	pNOD->close();
	
	return es;		
}

Acad::ErrorStatus deleteInNOD(const char *entryname)
{
	return deleteInNOD(NULL,entryname);
}

Acad::ErrorStatus 
deleteInNOD(AcDbDatabase *pTargetDb, const AcDbObjectId eId)
{

	Acad::ErrorStatus es;

	if(pTargetDb==NULL)
		pTargetDb = acdbHostApplicationServices()->workingDatabase();
	
	AcDbDictionary *pNOD = NULL;
	pTargetDb->getNamedObjectsDictionary(pNOD, AcDb::kForWrite);

	if(pNOD->has(eId)) {
		es = Acad::eOk;
	} else {
		es = Acad::eKeyNotFound;
	}

	if(es == Acad::eOk) {
		AcDbObject *pObj;
		acdbOpenAcDbObject(pObj, eId, AcDb::kForWrite); 
		AcDbDictionary *pDict;
		pDict = AcDbDictionary::cast(pObj);
		if(pDict) {
			if(pDict->numEntries()) es = Acad::eCannotBeErasedByCaller;
		}
		if(es == Acad::eOk) {
			pNOD->remove(eId);
			if(pObj->isReadEnabled()) pObj->upgradeOpen();
			es = pObj->erase();
		}
		pObj->close();
	}
	pNOD->close();
	
	return es;		
}

Acad::ErrorStatus deleteInNOD(const AcDbObjectId eId)
{
	return deleteInNOD(NULL,eId);
}

Acad::ErrorStatus 
deleteInNOD(AcDbDatabase *pTargetDb, AcDbObject *pObj)
{
	Acad::ErrorStatus es;

	if(pTargetDb==NULL)
		pTargetDb = acdbHostApplicationServices()->workingDatabase();
	
	AcDbDictionary *pNOD = NULL;
	pTargetDb->getNamedObjectsDictionary(pNOD, AcDb::kForWrite);

	AcDbObjectId eId;
	eId = pObj->objectId();

	if(pNOD->has(eId)) {
		es = Acad::eOk;
	} else {
		es = Acad::eKeyNotFound;
	}

	if(es == Acad::eOk) {
		AcDbDictionary *pDict;
		pDict = AcDbDictionary::cast(pObj);
		if(pDict) {
			if(pDict->numEntries()) es = Acad::eCannotBeErasedByCaller;
		}
		if(es == Acad::eOk) {
			pNOD->remove(eId);
			if(pObj->isReadEnabled()) pObj->upgradeOpen();
			es = pObj->erase();
		}
	}
	pNOD->close();
	
	return es;		
}

Acad::ErrorStatus deleteInNOD(AcDbObject *pObj)
{
	return deleteInNOD(NULL,pObj);
}

Acad::ErrorStatus 
deleteInDictionary(const AcDbObjectId eId, AcDbDictionary *pDict)
{
	assert(pDict != NULL);

	Acad::ErrorStatus es;
	es = pDict->remove(eId);

	if(es == Acad::eOk) {
		AcDbObject *pObj;
		acdbOpenAcDbObject(pObj, eId, AcDb::kForWrite);  		
		es = pObj->erase();
		pObj->close();
	}
		
	return es;
}

Acad::ErrorStatus 
deleteInDictionary(const char *entryname, AcDbDictionary *pDict)
{
	assert( !(entryname==NULL || *entryname=='\0') );
	assert(pDict != NULL);

	Acad::ErrorStatus es;
	AcDbObjectId eId;
	es = pDict->getAt(entryname,eId);

	if(es == Acad::eOk) {
		pDict->remove(entryname);
		AcDbObject *pObj;
		acdbOpenAcDbObject(pObj, eId, AcDb::kForWrite);  		
		es = pObj->erase();
		pObj->close();
	}
		
	return es;
}

Acad::ErrorStatus 
deleteInDictionary(AcDbObject *pObj, AcDbDictionary *pDict)
{
	assert(pDict != NULL);

	Acad::ErrorStatus es;
	AcDbObjectId eId;
	eId = pObj->id();

	es = pDict->remove(eId);
	if(es==Acad::eOk) {
		if(pObj->isReadEnabled()) pObj->upgradeOpen();
		es = pObj->erase();
	}	
	
	return es;
}