Acad::ErrorStatus CZhfPalette::Wblock(AcDbDatabase*& pDbFrom, AcDbDatabase*& pDbTo, /*const AcGePoint3d& pt_3d_base,*/ const AcGeMatrix3d & xform)
{
Acad::ErrorStatus es ;
AcDbObjectIdArray objIdsOut;
AcDbBlockTable* pBT = NULL ;
pDbFrom->getBlockTable(pBT, AcDb::kForRead);
AcDbBlockTableRecord* pBTR = NULL;
es = pBT->getAt(ACDB_MODEL_SPACE, pBTR, AcDb::kForRead);
pBT->close();
AcDbBlockTableRecordIterator* pIT;
es = pBTR->newIterator(pIT) ;
for (; !pIT->done(); pIT->step())
{
AcDbEntity* pEnt = NULL ;
if (Acad::eOk==pIT->getEntity(pEnt, AcDb::kForRead))
{
// if (!pEnt->isKindOf(AcDbAttributeDefinition::desc()))
// {
AcDbObjectId objId;
if (Acad::eOk == pIT->getEntityId(objId))
{
objIdsOut.append(objId);
}
// }
pEnt->close() ;
}
}
delete pIT;
pBTR->close();
if (!objIdsOut.isEmpty())
{
for (int i=0; i<objIdsOut.length(); i++)
{
AcDbObjectId objId = objIdsOut.at(i);
AcDbEntity *pEnt = NULL ;
if(Acad::eOk==acdbOpenAcDbEntity(pEnt,objId, AcDb::kForRead))
{
AcDbObjectId objIdDic ;
if ((objIdDic = pEnt->extensionDictionary())!= AcDbObjectId::kNull)
{
AcDbDictionary *pDict = NULL;
if (Acad::eOk==acdbOpenObject(pDict, objIdDic, AcDb::kForWrite))
{
pDict->setTreatElementsAsHard(Adesk::kTrue);
pDict->close();
}
}
pEnt->close() ;
}
}
AcDbDatabase *pTempDb ;
es = pDbFrom->wblock( pTempDb, objIdsOut, AcGePoint3d::kOrigin ) ;
if (Acad::eOk != es )
{
acedAlert( _T("wblock failed!") );
return es ;
}
es = pDbTo->insert( xform, pTempDb ) ;
if (Acad::eOk != es)
acedAlert( _T("insert failed!" ));
if (pTempDb)
{
delete pTempDb;
pTempDb = NULL ;
}
}
else
{
acutPrintf(_T("\nNo entities found in model space of DWG"));
}
return es ;
}
// 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();
}