Среда программирования Библиотеки C++ (стр. 56 )

AsdkEllipse(const AcDbObjectIdArray& ellipses,

const AcGePoint3d& center,

const AcGeVector3d& unitNormal,

const AcGeVector3d& majorAxis,

double radiusRatio,

double startAngle = 0.0,

double endAngle = 6.28318530717958647692);

AcDbObjectId ellipseId(unsigned short which);

Acad::ErrorStatus setEllipseId(

const AcDbObjectId& objId, unsigned short which);

Acad::ErrorStatus setEllipseIds(

const AcDbObjectIdArray& Ids);

Acad::ErrorStatus appendId(const AcDbObjectId& objId);

Acad::ErrorStatus appendIds(

const AcDbObjectIdArray& objIds);

inline Adesk::Boolean removeId(

const AcDbObjectId& objId);

// AcDbObject overrides.

//

virtual Acad::ErrorStatus subErase(

Adesk::Boolean pErasing);

virtual Acad::ErrorStatus dwgInFields(

AcDbDwgFiler* filer);

virtual Acad::ErrorStatus dwgOutFields(

AcDbDwgFiler* filer) const;

virtual Acad::ErrorStatus dxfInFields(

AcDbDxfFiler* filer);

virtual Acad::ErrorStatus dxfOutFields(

AcDbDxfFiler* filer) const;

virtual Acad::ErrorStatus wblockClone(

AcRxObject* pOwnerObject,

AcDbObject*& pClonedObject,

AcDbIdMapping& idMap,

Adesk::Boolean isPrimary = Adesk::kTrue) const;

// AcDbEntity overrides.

//

virtual void list() const;

// AcRxObject overrides.

//

virtual AcRxObject* clone() const;

private:

AcDbObjectIdArray mEllipseIds;

static int mInFlux; // == 1 when first object’s

// subErase is active.

};

ACRX_DXF_DEFINE_MEMBERS(AsdkEllipse, AcDbEllipse,

AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent, 0, ASDKELLIPSE,

REFERENC);

// Static class data member definition.

//

int AsdkEllipse::mInFlux = Adesk::kFalse;

AsdkEllipse::AsdkEllipse(const AsdkEllipse& master)

{

set(master. center(), master. normal(),

master. majorAxis(), master. radiusRatio(),

master. startAngle(), master. endAngle());

mEllipseIds = master. mEllipseIds;

}

AsdkEllipse::AsdkEllipse(const AcGePoint3d& center,

const AcGeVector3d& unitNormal,

const AcGeVector3d& majorAxis,

double radiusRatio,

double startAngle,

double endAngle) :

AcDbEllipse(center, unitNormal, majorAxis, radiusRatio,

startAngle, endAngle)

{ }

AsdkEllipse::AsdkEllipse(const AcDbObjectIdArray& ellipses,

const AcGePoint3d& center,

const AcGeVector3d& unitNormal,

const AcGeVector3d& majorAxis,

double radiusRatio,

double startAngle,

double endAngle) :

AcDbEllipse(center, unitNormal, majorAxis, radiusRatio,

startAngle, endAngle), mEllipseIds(ellipses)

{ }

AcDbObjectId

AsdkEllipse::ellipseId(unsigned short which)

{

assertReadEnabled();

if (which > mEllipseIds. length())

return AcDbObjectId::kNull;

return mEllipseIds[which];

}

Acad::ErrorStatus

AsdkEllipse::setEllipseId(const AcDbObjectId& objId,

unsigned short which)

{

assertWriteEnabled();

if (which > mEllipseIds. length())

return Acad::eInvalidIndex;

mEllipseIds[which] = objId;

return Acad::eOk;

}

Acad::ErrorStatus

AsdkEllipse::setEllipseIds(const AcDbObjectIdArray& objIds)

{

assertWriteEnabled();

if (objIds. length() == 0)

return Acad::eNullObjectId;

mEllipseIds = objIds;

return Acad::eOk;

}

Acad::ErrorStatus

AsdkEllipse::appendId(const AcDbObjectId& objId)

{

assertWriteEnabled();

if (objId == AcDbObjectId::kNull)

return Acad::eNullObjectId;

mEllipseIds. append(objId);

return Acad::eOk;

}

Acad::ErrorStatus

AsdkEllipse::appendIds(const AcDbObjectIdArray& objIds)

{

assertWriteEnabled();

if (objIds. length() == 0)

return Acad::eNullObjectId;

mEllipseIds. append(objIds);

return Acad::eOk;

}

inline Adesk::Boolean

AsdkEllipse::removeId(const AcDbObjectId& objId)

{

assertWriteEnabled();

return mEllipseIds. remove(objId);

}

// This implementation of subErase opens and erases all

// objects that this entity has hard pointer references

// to. The effect is that when one AsdkEllipse is erased,

// all the others it has hard pointers to also erase as

// a "group".

//

Acad::ErrorStatus

AsdkEllipse::subErase(Adesk::Boolean pErasing)

{

Acad::ErrorStatus es = AcDbEllipse::subErase(pErasing);

if (es!= Acad::eOk)

return es;

if (mInFlux == Adesk::kFalse) {

mInFlux = Adesk::kTrue;

AsdkEllipse *pEllipse;

int es;

for (int i = 0; i < mEllipseIds. length(); i++) {

es = acdbOpenObject(pEllipse, mEllipseIds[i],

AcDb::kForWrite, Adesk::kTrue);

if (es!= Acad::eOk)

continue;

pEllipse->erase(pErasing);

pEllipse->close();

}

mInFlux = Adesk::kFalse;

}

return Acad::eOk;

}

Acad::ErrorStatus

AsdkEllipse::dwgInFields(AcDbDwgFiler* filer)

{

assertWriteEnabled();

AcDbEllipse::dwgInFields(filer);

mEllipseIds. setLogicalLength(0);

int idCount;

filer->readInt32((long*)&idCount);

AcDbHardPointerId objId;

for (int i = 0; i < idCount; i++) {

filer->readItem(&objId);

mEllipseIds. append(objId);

}

return filer->filerStatus();

}

Acad::ErrorStatus

AsdkEllipse::dwgOutFields(AcDbDwgFiler* filer) const

{

assertReadEnabled();

AcDbEllipse::dwgOutFields(filer);

filer->writeInt32(mEllipseIds. length());

for (int i = 0; i < mEllipseIds. length(); i++) {

filer->writeHardPointerId(mEllipseIds[i]);

}

return filer->filerStatus();

}

Acad::ErrorStatus

AsdkEllipse::dxfInFields(AcDbDxfFiler* filer)

{

assertWriteEnabled();

Acad::ErrorStatus es = AcDbEllipse::dxfInFields(filer);

if (es!= Acad::eOk) {

return es;

}

// Check to see if we’re at the right subclass data

// marker.

//

if (!filer->atSubclassData("AsdkEllipse")) {

return Acad::eBadDxfSequence;

}

struct resbuf inbuf;

AcDbObjectId objId;

int idCount;

filer->readItem(&inbuf);

if (inbuf. restype == AcDb::kDxfInt32) {

idCount = inbuf. resval. rint;

} else {

filer->pushBackItem();

filer->setError(Acad::eInvalidDxfCode,

"\nError: expected group code %d",

AcDb::kDxfInt32);

return filer->filerStatus();

}

for (int i = 0; i < idCount; i++) {

es = filer->readItem(&inbuf);

if (es!= Acad::eOk) {

filer->setError(Acad::eMissingDxfField,

"\nError: expected more group code %d’s",

AcDb::kDxfHardPointerId);

return filer->filerStatus();

}

if (inbuf. restype == AcDb::kDxfHardPointerId) {

acdbGetObjectId(objId, inbuf. resval. rlname);

mEllipseIds. append(objId);

} else {

filer->pushBackItem();

filer->setError(Acad::eInvalidDxfCode,

"\nError: expected group code %d",

AcDb::kDxfHardPointerId);

return filer->filerStatus();

}

}

return filer->filerStatus();

}

Acad::ErrorStatus

AsdkEllipse::dxfOutFields(AcDbDxfFiler* filer) const

{

assertReadEnabled();

AcDbEllipse::dxfOutFields(filer);

filer->writeItem(AcDb::kDxfSubclass, "AsdkEllipse");

filer->writeInt32(AcDb::kDxfInt32,

mEllipseIds. length());

for (int i = 0; i < mEllipseIds. length(); i++) {

filer->writeObjectId(AcDb::kDxfHardPointerId,

mEllipseIds[i]);

}

return filer->filerStatus();

}

void

AsdkEllipse::list() const

{

assertReadEnabled();

AcDbEllipse::list();

acutPrintf("\nClass:\t%s", isA()->name());

for (int i = 0; i < mEllipseIds. length(); i++) {

acutPrintf("\nReferenceId[%d]:\t%ld", i,

(mEllipseIds[i]).asOldId());

}

}

// Called whenever an object of this class is dragged,

// moved, stretched, rotated, etc. so be careful what

// this function is made to do.

//

AcRxObject*

AsdkEllipse::clone() const

{

assertReadEnabled();

return new AsdkEllipse(*this);

}

Acad::ErrorStatus

AsdkEllipse::wblockClone(

AcRxObject* pOwnerObject,

AcDbObject*& pClonedObject,

AcDbIdMapping& idMap,

Adesk::Boolean isPrimary) const

{

assertReadEnabled();

static AcDbObjectId btr, pspace = AcDbObjectId::kNull;

AcTransaction *pTrans = NULL;

pClonedObject = NULL;

if (pspace == AcDbObjectId::kNull) {

AcDbBlockTable *pTable;

database()->getSymbolTable(pTable, AcDb::kForRead);

pTable->getAt(ACDB_PAPER_SPACE, pspace);

pTable->close();

}

if ( idMap. deepCloneContext() == AcDb::kDcXrefBind && ownerId() == pspace)

return Acad::eOk;

// Have we already done this entity?

//

AcDbIdPair idPair(objectId(), (AcDbObjectId)NULL, Adesk::kTrue);

if (pute(idPair) == TRUE && idPair. value() != NULL)

{

pClonedObject = NULL;

return Acad::eOk;

}

AcDbBlockTableRecord *pBTR = AcDbBlockTableRecord::cast(pOwnerObject);

if (pBTR != NULL) {

if (isPrimary == Adesk::kTrue)

btr = pBTR->objectId();

else

btr = AcDbObjectId::kNull;

} else if (btr!= AcDbObjectId::kNull) {

pTrans = actrTransactionManager->startTransaction();

pTrans->getObject((AcDbObject*&)pBTR, btr,

AcDb::kForWrite);

pOwnerObject = pBTR;

}

Acad::ErrorStatus es = AcDbEllipse::wblockClone(pOwnerObject,

pClonedObject, idMap, btr!= AcDbObjectId::kNull);

if (pTrans)

actrTransactionManager->endTransaction();

acutPrintf("\nWblockClone error status: %s",

acadErrorStatusText(es));

return Acad::eOk;

}

void

createEllipses()

{

const ellipseCount = 10;

AsdkEllipse *pEllipse;

pEllipse = new AsdkEllipse(AcGePoint3d(4.0, 4.0, 0.0),

AcGeVector3d(0.0, 0.0, 1.0),

AcGeVector3d(2.0, 0.0, 0.0),

0.5);

AcDbVoidPtrArray ellipses;

ellipses. append(pEllipse);

// Now use the getTransformedCopy() function with a

// scaling matrix (in X & Y only) to create new

// AsdkEllipses, each 0.5 units larger than the last in

// the X & Y direction, but identical in the Z

// direction. This would be similar to the

// getOffsetCurves() function, but that function

// returns AcDbSpline entities instead of AcDbEllipses.

//

double j = 1.1;

AcGeMatrix3d scale;