2163 lines
41 KiB
C++
2163 lines
41 KiB
C++
#include "stdafx.h"
|
|
#include "KTExtractDwgFiler.h"
|
|
#include "comdef.h"
|
|
#include "base64.h"
|
|
|
|
ACRX_CONS_DEFINE_MEMBERS(KTExtractDwgFiler, AcDbDwgFiler, 0);
|
|
|
|
namespace
|
|
{
|
|
void FormatPoint(TCHAR szBuff[], ads_point pt)
|
|
{
|
|
_stprintf(szBuff, _T("(%d,%d,%d)"), (int)(pt[X] + 0.5), (int)(pt[Y] + 0.5), (int)(pt[Z] + 0.5));
|
|
}
|
|
|
|
double __ttof(LPCTSTR pszString)
|
|
{
|
|
bool bSign = false;
|
|
bool bPowerSign = false;
|
|
bool bExponent = true;
|
|
bool bMantissa = false;
|
|
|
|
int nPower = 0;
|
|
double dExponent = 0.0;
|
|
double dMantissa = 0.0;
|
|
double dScale = 1.0;
|
|
TCHAR* pIn = (TCHAR*)pszString;
|
|
|
|
if (*pIn == _T('-'))
|
|
{
|
|
*pIn++;
|
|
bSign = true;
|
|
}
|
|
|
|
while (*pIn != 0)
|
|
{
|
|
// capture digits
|
|
if ((*pIn >= _T('0')) && (*pIn <= _T('9')))
|
|
{
|
|
if (bExponent)
|
|
{
|
|
dExponent *= 10.0;
|
|
dExponent += (*pIn - _T('0'));
|
|
}
|
|
else if (bMantissa)
|
|
{
|
|
dMantissa *= 10.0;
|
|
dMantissa += (*pIn - _T('0'));
|
|
|
|
dScale *= 10.0;
|
|
}
|
|
else
|
|
{
|
|
nPower *= 10;
|
|
nPower += (*pIn - _T('0'));
|
|
}
|
|
}
|
|
else if ((*pIn == _T('e')) || (*pIn == _T('E')))// power
|
|
{
|
|
// sign
|
|
if (*(++pIn) == _T('-'))
|
|
{
|
|
bPowerSign = true;
|
|
}
|
|
|
|
bMantissa = false;
|
|
}
|
|
else
|
|
{
|
|
// the first character that hasn't been accounted for already,
|
|
// is assumed to be the separator
|
|
// cross over
|
|
if (bExponent)
|
|
{
|
|
bExponent = false;
|
|
bMantissa = true;
|
|
}
|
|
// white space (including null) or bad char
|
|
// we're done either way
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
pIn++;
|
|
}
|
|
|
|
double dVal = dExponent + (dMantissa / dScale);
|
|
if (nPower > 0)
|
|
{
|
|
for (; nPower > 0; nPower--)
|
|
{
|
|
if (bPowerSign)
|
|
{
|
|
dVal /= 10.0;
|
|
}
|
|
else
|
|
{
|
|
dVal *= 10.0;
|
|
}
|
|
}
|
|
}
|
|
if (bSign)
|
|
{
|
|
dVal *= -1.0;
|
|
}
|
|
return dVal;
|
|
}
|
|
}
|
|
|
|
KTExtractDwgFiler::KTExtractDwgFiler()
|
|
: m_filerType(AcDb::kCopyFiler)
|
|
{
|
|
m_pxDataMap = NULL;
|
|
}
|
|
|
|
KTExtractDwgFiler::~KTExtractDwgFiler()
|
|
{
|
|
if (m_pxDataMap != NULL)
|
|
{
|
|
delete m_pxDataMap;
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::filerStatus() const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
AcDb::FilerType KTExtractDwgFiler::filerType() const
|
|
{
|
|
return m_filerType;
|
|
}
|
|
|
|
void KTExtractDwgFiler::setFilerStatus(Acad::ErrorStatus es)
|
|
{
|
|
}
|
|
|
|
void KTExtractDwgFiler::resetFilerStatus()
|
|
{
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeHardOwnershipId(const AcDbHardOwnershipId& id)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("HardOwnershipId"));
|
|
|
|
CString sText;
|
|
|
|
|
|
#ifdef _WIN64
|
|
sText.Format(_T("%lld"),id.asOldId());
|
|
#else
|
|
sText.Format(_T("%d"),id.asOldId());
|
|
#endif
|
|
|
|
m_arItemLines.Add(sText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeSoftOwnershipId(const AcDbSoftOwnershipId& id)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("SoftOwnershipId"));
|
|
|
|
//不涉及到用户数据
|
|
CString sText;
|
|
|
|
#ifdef _WIN64
|
|
sText.Format(_T("%lld"),id.asOldId());
|
|
#else
|
|
sText.Format(_T("%d"),id.asOldId());
|
|
#endif
|
|
m_arItemLines.Add(sText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeHardPointerId(const AcDbHardPointerId& id)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("HardPointerId"));
|
|
|
|
//不涉及到用户数据
|
|
CString sText;
|
|
|
|
#ifdef _WIN64
|
|
sText.Format(_T("%lld"),id.asOldId());
|
|
#else
|
|
sText.Format(_T("%d"),id.asOldId());
|
|
#endif
|
|
m_arItemLines.Add(sText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeSoftPointerId(const AcDbSoftPointerId& id)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("SoftPointerId"));
|
|
|
|
//不涉及到用户数据
|
|
CString sText;
|
|
|
|
#ifdef _WIN64
|
|
sText.Format(_T("%lld"),id.asOldId());
|
|
#else
|
|
sText.Format(_T("%d"),id.asOldId());
|
|
#endif
|
|
m_arItemLines.Add(sText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeInt8(Adesk::Int8 nInt8)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("Adesk::Int8"));
|
|
|
|
//不涉及到用户数据
|
|
CString sText;
|
|
sText.Format(_T("%d"),nInt8);
|
|
m_arItemLines.Add(sText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeChar(Adesk::Int8 ch)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("Adesk::Int8"));
|
|
|
|
//不涉及到用户数据
|
|
CString sText;
|
|
sText.Format(_T("%d"),ch);
|
|
m_arItemLines.Add(sText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeString(const ACHAR * pACHAR)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("String"));
|
|
|
|
m_arItemLines.Add(pACHAR);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
#if ARX>15
|
|
#include "acstring.h"
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeString(const AcString& str)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("String"));
|
|
|
|
m_arItemLines.Add(str);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
#endif
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeBChunk(const ads_binary& binar)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("binary"));
|
|
|
|
CString sText;
|
|
sText.Format(_T("%d"),m_arBinaryBufs.GetSize());
|
|
m_arItemLines.Add(sText);
|
|
|
|
binary_buf buf;
|
|
buf.nLen = binar.clen;
|
|
buf.pBuf = new byte[binar.clen];
|
|
memcpy(buf.pBuf,binar.buf,binar.clen);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeAcDbHandle(const AcDbHandle& dbhdl)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("Handle"));
|
|
|
|
TCHAR szText[256];
|
|
memset(szText,0,sizeof(szText));
|
|
dbhdl.getIntoAsciiBuffer(szText);
|
|
|
|
m_arItemLines.Add(szText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeInt32(Adesk::Int32 nInt32)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("Adesk::Int32"));
|
|
|
|
CString sText;
|
|
sText.Format(_T("%d"),nInt32);
|
|
m_arItemLines.Add(sText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeInt16(Adesk::Int16 nInt16)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("Adesk::Int16"));
|
|
|
|
CString sText;
|
|
sText.Format(_T("%d"),nInt16);
|
|
m_arItemLines.Add(sText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeUInt32(Adesk::UInt32 nUInt32)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("Adesk::UInt32"));
|
|
|
|
CString sText;
|
|
sText.Format(_T("%d"),nUInt32);
|
|
m_arItemLines.Add(sText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeUInt16(Adesk::UInt16 nUInt16)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("Adesk::UInt16"));
|
|
|
|
CString sText;
|
|
sText.Format(_T("%d"),nUInt16);
|
|
m_arItemLines.Add(sText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeUInt8(Adesk::UInt8 nUInt8)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("Adesk::UInt8"));
|
|
|
|
CString sText;
|
|
sText.Format(_T("%d"),nUInt8);
|
|
m_arItemLines.Add(sText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeBool(bool bVal)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("bool"));
|
|
|
|
CString sText;
|
|
sText.Format(_T("%d"),bVal ? TRUE : FALSE);
|
|
m_arItemLines.Add(sText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeBoolean(Adesk::Boolean bVal)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("Adesk::Boolean"));
|
|
CString sText;
|
|
sText.Format(_T("%d"),bVal);
|
|
m_arItemLines.Add(sText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeDouble(double dVal)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("double"));
|
|
|
|
CString sText;
|
|
sText.Format(_T("%g"),dVal);
|
|
m_arItemLines.Add(sText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writePoint2d(const AcGePoint2d& pt2d)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("Point2d"));
|
|
|
|
TCHAR szText[256];
|
|
memset(szText,0,sizeof(szText));
|
|
FormatPoint(szText,asDblArray(pt2d));
|
|
|
|
m_arItemLines.Add(szText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writePoint3d(const AcGePoint3d& pt3d)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("Point3d"));
|
|
|
|
TCHAR szText[256];
|
|
memset(szText,0,sizeof(szText));
|
|
|
|
FormatPoint(szText,asDblArray(pt3d));
|
|
m_arItemLines.Add(szText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeVector2d(const AcGeVector2d& vec2d)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("Vector2d"));
|
|
|
|
TCHAR szText[256];
|
|
memset(szText,0,sizeof(szText));
|
|
|
|
FormatPoint(szText,asDblArray(vec2d));
|
|
m_arItemLines.Add(szText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeVector3d(const AcGeVector3d& vec3d)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("Vector3d"));
|
|
|
|
TCHAR szText[256];
|
|
memset(szText,0,sizeof(szText));
|
|
|
|
FormatPoint(szText,asDblArray(vec3d));
|
|
m_arItemLines.Add(szText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeScale3d(const AcGeScale3d& scl3d)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("Scale3d"));
|
|
|
|
TCHAR szText[256];
|
|
memset(szText,0,sizeof(szText));
|
|
|
|
FormatPoint(szText,asDblArray(AcGePoint3d(scl3d.sx,scl3d.sy,scl3d.sz)) );
|
|
m_arItemLines.Add(szText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
#if ARX<18
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeBytes(const void* pByte, Adesk::UInt32 nLen)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("Bytes"));
|
|
|
|
CString sText;
|
|
sText.Format(_T("%d"),m_arBinaryBufs.GetSize() );
|
|
m_arItemLines.Add(sText);
|
|
|
|
binary_buf buf;
|
|
buf.nLen = nLen;
|
|
buf.pBuf = new byte[buf.nLen];
|
|
memcpy(buf.pBuf,pByte,nLen);
|
|
|
|
m_arBinaryBufs.Add(buf);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
#endif
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeAddress(const void* pAddr)
|
|
{
|
|
//不涉及到用户数据
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(const AcDbHardOwnershipId& id)
|
|
{
|
|
return writeHardOwnershipId(id);
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(const AcDbSoftOwnershipId& id)
|
|
{
|
|
return writeSoftOwnershipId(id);
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(const AcDbHardPointerId& id)
|
|
{
|
|
return writeHardPointerId(id);
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(const AcDbSoftPointerId& id)
|
|
{
|
|
return writeSoftPointerId(id);
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(const ACHAR * pStr)
|
|
{
|
|
return writeString(pStr);
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(const ads_binary& binar)
|
|
{
|
|
return writeBChunk(binar);
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(const AcDbHandle& hdl)
|
|
{
|
|
return writeAcDbHandle(hdl);
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(Adesk::Int32 nInt32)
|
|
{
|
|
return writeInt32(nInt32);
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(Adesk::Int16 nInt16)
|
|
{
|
|
return writeInt16(nInt16);
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(Adesk::Int8 nInt8)
|
|
{
|
|
return writeInt8(nInt8);
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(Adesk::UInt32 nUInt32)
|
|
{
|
|
return writeUInt32(nUInt32);
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(Adesk::UInt16 nUInt16)
|
|
{
|
|
return writeUInt16(nUInt16);
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(Adesk::UInt8 nUInt8)
|
|
{
|
|
return writeUInt8(nUInt8);
|
|
}
|
|
|
|
#ifndef Adesk_Boolean_is_bool
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(Adesk::Boolean bVal)
|
|
{
|
|
return writeBoolean(bVal);
|
|
}
|
|
#else
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(bool bVal)
|
|
{
|
|
return writeBool(bVal);
|
|
}
|
|
#endif
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(double dVal)
|
|
{
|
|
return writeDouble(dVal);
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(const AcGePoint2d& pt2d)
|
|
{
|
|
return writePoint2d(pt2d);
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(const AcGePoint3d& pt3d)
|
|
{
|
|
return writePoint3d(pt3d);
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(const AcGeVector2d& pt2d)
|
|
{
|
|
return writeVector2d(pt2d);
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(const AcGeVector3d& pt3d)
|
|
{
|
|
return writeVector3d(pt3d);
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(const AcGeScale3d& pt3d)
|
|
{
|
|
return writeScale3d(pt3d);
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(const void* pBuf, Adesk::UInt32 nLen)
|
|
{
|
|
return Acad::eOk;;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeItem(const void * pBuf)
|
|
{
|
|
return writeAddress(pBuf);
|
|
}
|
|
|
|
//取所有autocad 平台的相同的部分，所以下面64位不处理
|
|
#if ARX>17
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeInt64(Adesk::Int64 nVal)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("Adesk::Int64"));
|
|
|
|
CString sText;
|
|
sText.Format(_T("%d"),nVal);
|
|
m_arItemLines.Add(sText);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeUInt64(Adesk::UInt64 nVal)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("Adesk::UInt64"));
|
|
|
|
CString sText;
|
|
sText.Format(_T("%d"),nVal);
|
|
m_arItemLines.Add(sText);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus KTExtractDwgFiler::writeBytes(const void * pbuf, Adesk::UIntPtr nLen)
|
|
{
|
|
//占位
|
|
m_arSerialDNA.Add(_T("Bytes"));
|
|
|
|
CString sText;
|
|
sText.Format(_T("%d"),m_arBinaryBufs.GetSize() );
|
|
m_arItemLines.Add(sText);
|
|
|
|
binary_buf buf;
|
|
buf.nLen = nLen;
|
|
buf.pBuf = new byte[buf.nLen];
|
|
memcpy(buf.pBuf,pbuf,nLen);
|
|
|
|
m_arBinaryBufs.Add(buf);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
#endif
|
|
|
|
int KTExtractDwgFiler::ReadLinesByLockedSerialDNA(CStringArray& arLockDNA,CStringArray& arLines)
|
|
{
|
|
BOOL bFind = FALSE;
|
|
int nIndex = 0,nCount = 0;
|
|
CString sLockDNA,sDNA;
|
|
|
|
for (int i = 0;i < arLockDNA.GetSize();i++)
|
|
{
|
|
sLockDNA = arLockDNA.GetAt(i);
|
|
if (nIndex + i > m_arSerialDNA.GetSize() - 1)
|
|
{
|
|
break;
|
|
}
|
|
sDNA = m_arSerialDNA.GetAt(nIndex + i);
|
|
|
|
if (sDNA.CompareNoCase(sLockDNA) != 0)
|
|
{
|
|
nIndex += 1;
|
|
i = -1;
|
|
nCount = 0;
|
|
bFind = FALSE;
|
|
}
|
|
else
|
|
{
|
|
nCount += 1;
|
|
}
|
|
|
|
if (nCount == arLockDNA.GetSize())
|
|
{
|
|
bFind = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (bFind)
|
|
{
|
|
for (int ii = 0;ii < arLockDNA.GetSize();ii++)
|
|
{
|
|
arLines.Add(m_arItemLines.GetAt(nIndex + ii));
|
|
}
|
|
return (nIndex + ii);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int KTExtractDwgFiler::FindPositionByDNATypes(CStringArray& arLockDNA)
|
|
{
|
|
BOOL bFind = FALSE;
|
|
int nIndex = 0,nCount = 0;
|
|
CString sLockDNA,sDNA;
|
|
|
|
for (int i = 0;i < arLockDNA.GetSize();i++)
|
|
{
|
|
sLockDNA = arLockDNA.GetAt(i);
|
|
if (nIndex + i > m_arSerialDNA.GetSize() - 1)
|
|
{
|
|
break;
|
|
}
|
|
sDNA = m_arSerialDNA.GetAt(nIndex + i);
|
|
|
|
if (sDNA.CompareNoCase(sLockDNA) != 0)
|
|
{
|
|
nIndex += 1;
|
|
i = -1;
|
|
nCount = 0;
|
|
bFind = FALSE;
|
|
}
|
|
else
|
|
{
|
|
nCount += 1;
|
|
}
|
|
|
|
if (nCount == arLockDNA.GetSize())
|
|
{
|
|
bFind = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (bFind)
|
|
{
|
|
/*for (int ii = 0;ii < arLockDNA.GetSize();ii++)
|
|
{
|
|
arLines.Add(m_arItemLines.GetAt(nIndex + ii));
|
|
}
|
|
return (nIndex + ii);
|
|
*/
|
|
return nIndex;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
BOOL KTExtractDwgFiler::ReadDNASegmentInSection(CStringArray& arLockDNA,CStringArray& arLines,LPCTSTR pszDNAType,LPCTSTR pszDNATypeBefor)
|
|
{
|
|
CStringArray arTLines;
|
|
int nIndex = ReadLinesByLockedSerialDNA(arLockDNA,arTLines);
|
|
BOOL bFind = FALSE;
|
|
|
|
if (nIndex != -1 && nIndex < m_arItemLines.GetSize())
|
|
{
|
|
CString sType;
|
|
while(TRUE)
|
|
{
|
|
//找到第一次出现的DNA
|
|
sType = m_arSerialDNA.GetAt(nIndex);
|
|
if (sType.CompareNoCase(pszDNAType) == 0)
|
|
{
|
|
bFind = TRUE;
|
|
arLines.Add(m_arItemLines.GetAt(nIndex));
|
|
}
|
|
else
|
|
{
|
|
if (sType.CompareNoCase(pszDNATypeBefor) == 0)//止
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (bFind)//结束
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
nIndex += 1;
|
|
if (nIndex >= m_arSerialDNA.GetSize())
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return bFind;
|
|
}
|
|
|
|
BOOL KTExtractDwgFiler::ReadDNAAtPosition(int& nIndex,CString& sDNAType,CString& sLine)
|
|
{
|
|
if (nIndex != -1 && nIndex < m_arItemLines.GetSize())
|
|
{
|
|
sDNAType = m_arSerialDNA.GetAt(nIndex);
|
|
sLine = m_arItemLines.GetAt(nIndex);
|
|
nIndex += 1;
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
AecXDataMap* KTExtractDwgFiler::FormatDataMap()
|
|
{
|
|
if (m_pxDataMap != NULL)
|
|
delete m_pxDataMap;
|
|
|
|
m_pxDataMap = new AecXDataMap;
|
|
m_pxDataMap->FormatDataMap(m_arItemLines);
|
|
|
|
return m_pxDataMap;
|
|
}
|
|
|
|
|
|
#define MAP_BLOCK_BEGIN _T("TDBXDATAMAP_BLOCK_BEGIN_")
|
|
#define MAP_BLOCK_END _T("TDBXDATAMAP_BLOCK_END_")
|
|
#define DIF_VT_PT _T("$vector3d")
|
|
|
|
AecXDataMap::AecXDataMap()
|
|
{
|
|
}
|
|
|
|
AecXDataMap::~AecXDataMap()
|
|
{
|
|
//释放 xData 是自符串的元素
|
|
std::map<CString, XData>::iterator itor;
|
|
for (itor = m_xData.begin(); itor != m_xData.end(); ++itor)
|
|
{
|
|
|
|
if (itor->second.nVt == VT_BSTR ||
|
|
itor->second.nVt == (VT_BYREF | VT_R8 + 4))
|
|
{
|
|
if (itor->second.pszVal != NULL && itor->second.npszLen > 0)
|
|
{
|
|
delete[] itor->second.pszVal;
|
|
itor->second.pszVal = NULL;
|
|
itor->second.npszLen = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL AecXDataMap::SetAt(LPCTSTR pszKey, int nVal)
|
|
{
|
|
if (pszKey != NULL)
|
|
{
|
|
XData xdata;
|
|
memset(&xdata, 0, sizeof(xdata));
|
|
xdata.nVt = VT_I4;
|
|
xdata.nVal = nVal;
|
|
|
|
It it = m_xData.find(pszKey);
|
|
if (it != m_xData.end())
|
|
{
|
|
(*it).second = xdata;
|
|
}
|
|
else
|
|
{
|
|
std::pair<CString, XData> pa(pszKey, xdata);
|
|
m_xData.insert(pa);
|
|
}
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::SetAt(LPCTSTR pszKey, double dVal)
|
|
{
|
|
if (pszKey != NULL)
|
|
{
|
|
XData xdata;
|
|
memset(&xdata, 0, sizeof(xdata));
|
|
xdata.nVt = VT_R8;
|
|
xdata.dVal[0] = dVal;
|
|
|
|
It it = m_xData.find(pszKey);
|
|
if (it != m_xData.end())
|
|
{
|
|
(*it).second = xdata;
|
|
}
|
|
else
|
|
{
|
|
std::pair<CString, XData> pa(pszKey, xdata);
|
|
m_xData.insert(pa);
|
|
}
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::SetAt(LPCTSTR pszKey, const AcGeDoubleArray& arVal)
|
|
{
|
|
if (pszKey != NULL)
|
|
{
|
|
CString sSubKey;
|
|
for (int i = 0; i < arVal.length(); ++i)
|
|
{
|
|
sSubKey.Format(_T("%s%d"), pszKey, i);
|
|
SetAt(sSubKey, arVal[i]);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
BOOL AecXDataMap::SetAt(LPCTSTR pszKey, const AcGeVector3d& vt, BOOL bTransformBy)
|
|
{
|
|
/*
|
|
设置向量是在键值pszkey后增加字符串"$vector3d",与点进行区分
|
|
bTransformBy标识向量是否随cad实体所变化
|
|
*/
|
|
if (pszKey != NULL)
|
|
{
|
|
CString sTmpKey = pszKey;
|
|
sTmpKey += DIF_VT_PT;
|
|
XData xdata;
|
|
memset(&xdata, 0, sizeof(xdata));
|
|
xdata.nVt = (VT_BYREF | VT_R8 + 2);
|
|
if (bTransformBy)
|
|
{
|
|
// 向量随cad实体变化而改变
|
|
xdata.nVt = (VT_BYREF | VT_R8 + 3);
|
|
}
|
|
xdata.dVal[0] = vt.x;
|
|
xdata.dVal[1] = vt.y;
|
|
xdata.dVal[2] = vt.z;
|
|
|
|
It it = m_xData.find(sTmpKey);
|
|
if (it != m_xData.end())
|
|
{
|
|
(*it).second = xdata;
|
|
}
|
|
else
|
|
{
|
|
std::pair<CString, XData> pa(sTmpKey, xdata);
|
|
m_xData.insert(pa);
|
|
}
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::SetAt(LPCTSTR pszKey, const AcGePoint3d& ptGe, BOOL bTransformBy)
|
|
{
|
|
/*
|
|
bTransformBy标识点是否随cad实体所变化
|
|
*/
|
|
if (pszKey != NULL)
|
|
{
|
|
XData xdata;
|
|
memset(&xdata, 0, sizeof(xdata));
|
|
xdata.nVt = VT_BYREF | VT_R8;
|
|
if (bTransformBy)
|
|
{
|
|
// 点随cad实体变化而改变
|
|
xdata.nVt = (VT_BYREF | VT_R8 + 1);
|
|
}
|
|
|
|
xdata.dVal[0] = ptGe.x;
|
|
xdata.dVal[1] = ptGe.y;
|
|
xdata.dVal[2] = ptGe.z;
|
|
|
|
It it = m_xData.find(pszKey);
|
|
if (it != m_xData.end())
|
|
{
|
|
(*it).second = xdata;
|
|
}
|
|
else
|
|
{
|
|
std::pair<CString, XData> pa(pszKey, xdata);
|
|
m_xData.insert(pa);
|
|
}
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::SetAt(LPCTSTR pszKey, const AcGePoint3dArray& arPt, BOOL bTransformBy)
|
|
{
|
|
if (pszKey != NULL)
|
|
{
|
|
CString sSubKey;
|
|
for (int i = 0; i < arPt.length(); ++i)
|
|
{
|
|
sSubKey.Format(_T("%s%d"), pszKey, i);
|
|
SetAt(sSubKey, arPt[i], bTransformBy);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::SetAt(LPCTSTR pszKey, const AcGeMatrix3d& xform)
|
|
{
|
|
if (pszKey != NULL)
|
|
{
|
|
XData xdata;
|
|
memset(&xdata, 0, sizeof(xdata));
|
|
xdata.nVt = (VT_BYREF | VT_R8 + 4);
|
|
|
|
CString sText = _T(""), sTemp;
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
for (int j = 0; j < 4; j++)
|
|
{
|
|
sTemp.Format(_T("%g"), xform.entry[i][j]);
|
|
sText += _T(",") + sTemp;
|
|
}
|
|
}
|
|
sText.TrimLeft(_T(","));
|
|
|
|
xdata.npszLen = sText.GetLength() + 1;
|
|
xdata.pszVal = new TCHAR[xdata.npszLen];
|
|
_tcscpy(xdata.pszVal, sText);
|
|
|
|
It it = m_xData.find(pszKey);
|
|
if (it != m_xData.end()) //找到
|
|
{
|
|
if ((*it).second.nVt == VT_BSTR ||
|
|
(*it).second.nVt == (VT_BYREF | VT_R8 + 4))
|
|
{
|
|
if ((*it).second.npszLen > 0 && (*it).second.pszVal != NULL)
|
|
{
|
|
delete[](*it).second.pszVal;
|
|
}
|
|
}
|
|
|
|
(*it).second = xdata;
|
|
}
|
|
else //未找到
|
|
{
|
|
std::pair<CString, XData> pa(pszKey, xdata);
|
|
m_xData.insert(pa);
|
|
}
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static BOOL Script2StringArray(const CString& sScript, TCHAR tSpace, CStringArray& arTexts)
|
|
{
|
|
//x,y,z,d,a
|
|
int nPos = -1, nStart = 0;
|
|
CString sText;
|
|
|
|
while (TRUE)
|
|
{
|
|
nPos = sScript.Find(tSpace, nStart);
|
|
if (nPos != -1)
|
|
{
|
|
sText = sScript.Mid(nStart, nPos - nStart);
|
|
arTexts.Add(sText);
|
|
nStart = nPos + 1;
|
|
}
|
|
else
|
|
{
|
|
if (nStart <= sScript.GetLength() - 1)
|
|
{
|
|
sText = sScript.Mid(nStart);
|
|
arTexts.Add(sText);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return arTexts.GetSize() > 0;
|
|
}
|
|
|
|
BOOL AecXDataMap::GetAt(LPCTSTR pszKey, AcGeMatrix3d& xform) const
|
|
{
|
|
if (pszKey != NULL)
|
|
{
|
|
std::map<CString, XData>::const_iterator it;
|
|
if ((it = m_xData.find(pszKey)) != m_xData.end())
|
|
{
|
|
XData xdata = (*it).second;
|
|
if (xdata.nVt == (VT_BYREF | VT_R8 + 4))
|
|
{
|
|
CString sText = xdata.pszVal;
|
|
CStringArray arTexts;
|
|
|
|
Script2StringArray(sText, _T(','), arTexts);
|
|
if (arTexts.GetSize() == 16)
|
|
{
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
for (int j = 0; j < 4; j++)
|
|
{
|
|
xform.entry[i][j] = __ttof(arTexts.GetAt(i * 4 + j));
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::SetAt(LPCTSTR pszKey, LPCTSTR pszValue)
|
|
{
|
|
if (pszKey != NULL)
|
|
{
|
|
CString sTmp = pszValue;
|
|
if (sTmp.GetLength() >= MAX_PATH)
|
|
return FALSE;
|
|
|
|
if (_tcslen(pszValue) < 0)
|
|
return FALSE;
|
|
|
|
XData xdata;
|
|
memset(&xdata, 0, sizeof(xdata));
|
|
|
|
xdata.nVt = VT_BSTR;
|
|
xdata.npszLen = _tcslen(pszValue) + 1;
|
|
xdata.pszVal = new TCHAR[xdata.npszLen];
|
|
memset(xdata.pszVal, 0, xdata.npszLen);
|
|
_tcscpy(xdata.pszVal, pszValue);
|
|
|
|
It it = m_xData.find(pszKey);
|
|
if (it != m_xData.end())
|
|
{
|
|
// Rem:.2010.7.23 原来的要删除
|
|
if ((*it).second.npszLen > 0 && (*it).second.pszVal != NULL)
|
|
delete[](*it).second.pszVal;
|
|
|
|
//(*it).second = xdata;
|
|
(*it).second.pszVal = new TCHAR[xdata.npszLen];
|
|
memset((*it).second.pszVal, 0, xdata.npszLen);
|
|
_tcscpy((*it).second.pszVal, pszValue);
|
|
|
|
delete[] xdata.pszVal;
|
|
xdata.pszVal = NULL;
|
|
}
|
|
else
|
|
{
|
|
std::pair<CString, XData> pa(pszKey, xdata);
|
|
m_xData.insert(pa);
|
|
}
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::SetAt(LPCTSTR pszKey, int iIndex, LPCTSTR pszValue)
|
|
{
|
|
if (pszKey != NULL)
|
|
{
|
|
CString sKey;
|
|
sKey.Format(_T("%s_%d"), pszKey, iIndex);
|
|
return SetAt(sKey, pszValue);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::GetAt(LPCTSTR pszKey, int iIndex, CString &sValue)
|
|
{
|
|
if (pszKey != NULL)
|
|
{
|
|
CString sKey;
|
|
sKey.Format(_T("%s_%d"), pszKey, iIndex);
|
|
return GetAt(sKey, sValue);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::SetAt(LPCTSTR pszKey, int iIndex, const AecXDataMap& xDataMap)
|
|
{
|
|
//{key | type | inf}个隔开
|
|
CString sKey, sType, sInfo, sRecord, sText;
|
|
sText = _T("");
|
|
XData xdata;
|
|
memset(&xdata, 0, sizeof(XData));
|
|
|
|
typedef std::map<CString, XData>::const_iterator It;
|
|
for (It it = xDataMap.m_xData.begin(); it != xDataMap.m_xData.end(); ++it)
|
|
{
|
|
xdata = (*it).second;
|
|
sKey = (*it).first;
|
|
sType = _T("");
|
|
sInfo = _T("");
|
|
|
|
switch (xdata.nVt)
|
|
{
|
|
case VT_I4: // 整型
|
|
{
|
|
sType.Format(_T("%d"), VT_I4);
|
|
sInfo.Format(_T("%d"), xdata.nVal);
|
|
sRecord.Format(_T("{%s|%s|%s}"), sKey, sType, sInfo);
|
|
sText += sRecord;
|
|
break;
|
|
}
|
|
case VT_UI4:
|
|
{
|
|
sType.Format(_T("%d"), VT_UI4);
|
|
sInfo.Format(_T("%d"), xdata.nVal);
|
|
sRecord.Format(_T("{%s|%s|%s}"), sKey, sType, sInfo);
|
|
sText += sRecord;
|
|
break;
|
|
}
|
|
case VT_UI8:
|
|
{
|
|
sType.Format(_T("%d"), VT_UI8);
|
|
sInfo.Format(_T("%d"), xdata.nVal);
|
|
sRecord.Format(_T("{%s|%s|%s}"), sKey, sType, sInfo);
|
|
sText += sRecord;
|
|
break;
|
|
}
|
|
case VT_R8: // 浮点
|
|
{
|
|
sType.Format(_T("%d"), VT_R8);
|
|
sInfo.Format(_T("%g"), xdata.dVal[0]);
|
|
sRecord.Format(_T("{%s|%s|%s}"), sKey, sType, sInfo);
|
|
sText += sRecord;
|
|
break;
|
|
}
|
|
case (VT_BYREF | VT_R8): // 点
|
|
{
|
|
sType.Format(_T("%d"), (VT_BYREF | VT_R8));
|
|
sInfo.Format(_T("%.4f,%.4f,%.4f"), xdata.dVal[0], xdata.dVal[1], xdata.dVal[2]);
|
|
sRecord.Format(_T("{%s|%s|%s}"), sKey, sType, sInfo);
|
|
sText += sRecord;
|
|
break;
|
|
}
|
|
case (VT_BYREF | VT_R8 + 1): // cad变化点
|
|
{
|
|
sType.Format(_T("%d"), (VT_BYREF | VT_R8 + 1));
|
|
sInfo.Format(_T("%g,%g,%g"), xdata.dVal[0], xdata.dVal[1], xdata.dVal[2]);
|
|
sRecord.Format(_T("{%s|%s|%s}"), sKey, sType, sInfo);
|
|
sText += sRecord;
|
|
break;
|
|
}
|
|
case (VT_BYREF | VT_R8 + 2): // 向量
|
|
{
|
|
sType.Format(_T("%d"), (VT_BYREF | VT_R8 + 2));
|
|
sInfo.Format(_T("%g,%g,%g"), xdata.dVal[0], xdata.dVal[1], xdata.dVal[2]);
|
|
sRecord.Format(_T("{%s|%s|%s}"), sKey, sType, sInfo);
|
|
sText += sRecord;
|
|
break;
|
|
}
|
|
case (VT_BYREF | VT_R8 + 3): // 变化向量
|
|
{
|
|
sType.Format(_T("%d"), (VT_BYREF | VT_R8 + 3));
|
|
sInfo.Format(_T("%g,%g,%g"), xdata.dVal[0], xdata.dVal[1], xdata.dVal[2]);
|
|
sRecord.Format(_T("{%s|%s|%s}"), sKey, sType, sInfo);
|
|
sText += sRecord;
|
|
break;
|
|
}
|
|
case (VT_BYREF | VT_R8 + 4): // 矩阵
|
|
{
|
|
sType.Format(_T("%d"), VT_BYREF | VT_R8 + 4);
|
|
sInfo.Format(_T("%s"), xdata.pszVal);
|
|
sRecord.Format(_T("{%s|%s|%s}"), sKey, sType, sInfo);
|
|
sText += sRecord;
|
|
break;
|
|
}
|
|
case VT_BSTR: // 字符串
|
|
{
|
|
sType.Format(_T("%d"), VT_BSTR);
|
|
sInfo.Format(_T("%s"), xdata.pszVal);
|
|
sRecord.Format(_T("{%s|%s|%s}"), sKey, sType, sInfo);
|
|
sText += sRecord;
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (!sText.IsEmpty())
|
|
return SetAt(pszKey, iIndex, sText);
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::ParseToRecords(CString& sText, CStringArray& arRecords)
|
|
{
|
|
CString sRecord;
|
|
int nFr = 0, nTo = 0;
|
|
//{Key|Type|Info}...
|
|
while (TRUE)
|
|
{
|
|
nFr = sText.Find(_T("{"), 0);
|
|
nTo = sText.Find(_T("}"), 0);
|
|
if (nFr == 0 && nTo > 0)
|
|
{
|
|
sRecord = sText.Mid(nFr, nTo + 1);
|
|
sRecord.TrimLeft(_T("{"));
|
|
sRecord.TrimRight(_T("}"));
|
|
arRecords.Add(sRecord);
|
|
|
|
if (nTo + 1 < sText.GetLength())
|
|
{
|
|
sRecord = sText.Mid(nTo + 1);
|
|
sText = sRecord;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
return arRecords.GetSize() > 0;
|
|
}
|
|
|
|
BOOL AecXDataMap::ExtractRecord(CString& sRecord, CString& sKey, CString& sType, CString& sInfo)
|
|
{
|
|
//Key|int|Info
|
|
int nFr = sRecord.Find(_T("|"), 0);
|
|
if (nFr != -1)
|
|
{
|
|
CString sTemp;
|
|
sKey = sRecord.Mid(0, nFr);
|
|
if (nFr + 1 < sRecord.GetLength())
|
|
{
|
|
sTemp = sRecord.Mid(nFr + 1);
|
|
sRecord = sTemp;
|
|
|
|
nFr = sRecord.Find(_T("|"), 0);
|
|
if (nFr != -1)
|
|
{
|
|
sType = sRecord.Mid(0, nFr);
|
|
if (nFr + 1 < sRecord.GetLength())
|
|
{
|
|
sInfo = sRecord.Mid(nFr + 1);
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::StringToAcGePoint3d(CString& sText, AcGePoint3d& ptGe)
|
|
{
|
|
//x,y,z
|
|
CString sX, sY, sZ;
|
|
|
|
int nFr = sText.Find(_T(","), 0);
|
|
if (nFr != -1)
|
|
{
|
|
CString sTemp;
|
|
sX = sText.Mid(0, nFr);
|
|
if (nFr + 1 < sText.GetLength())
|
|
{
|
|
sTemp = sText.Mid(nFr + 1);
|
|
sText = sTemp;
|
|
|
|
nFr = sText.Find(_T(","), 0);
|
|
if (nFr != -1)
|
|
{
|
|
sY = sText.Mid(0, nFr);
|
|
if (nFr + 1 < sText.GetLength())
|
|
{
|
|
sZ = sText.Mid(nFr + 1);
|
|
ptGe.set(__ttof(sX), __ttof(sY), __ttof(sZ));
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::StringToAcGeVector3d(CString& sText, AcGeVector3d& vt)
|
|
{
|
|
//x,y,z
|
|
AcGePoint3d ptGe;
|
|
if (StringToAcGePoint3d(sText, ptGe))
|
|
{
|
|
vt = ptGe.asVector();
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::GetAt(LPCTSTR pszKey, int iIndex, AecXDataMap& xDataMap)
|
|
{
|
|
CString sKey, sType, sInfo, sText, sRecord;
|
|
AcGePoint3d ptGe;
|
|
AcGeVector3d vt;
|
|
BOOL bSuccess = FALSE;
|
|
AcDbObjectId id;
|
|
XData xDat;
|
|
|
|
if (GetAt(pszKey, iIndex, sText))
|
|
{
|
|
sText.TrimLeft();
|
|
sText.TrimRight();
|
|
|
|
if (sText.GetLength() > 1)
|
|
{
|
|
CStringArray arRecords;
|
|
bSuccess = ParseToRecords(sText, arRecords);
|
|
|
|
for (int i = 0; i < arRecords.GetSize(); i++)
|
|
{
|
|
sRecord = arRecords.GetAt(i);
|
|
if (ExtractRecord(sRecord, sKey, sType, sInfo))
|
|
{
|
|
int nVt = _ttoi(sType);
|
|
switch (nVt)
|
|
{
|
|
case VT_I4: // 整型
|
|
{
|
|
xDataMap.SetAt(sKey, _ttoi(sInfo));
|
|
break;
|
|
}
|
|
case VT_UI4:
|
|
{
|
|
#ifdef _WIN64
|
|
id.setFromOldId((INT_PTR)_ttoi64(sInfo));
|
|
#else
|
|
id.setFromOldId((INT_PTR)_ttoi(sInfo));
|
|
#endif
|
|
|
|
xDataMap.SetAt(sKey, id);
|
|
break;
|
|
}
|
|
case VT_UI8:
|
|
{
|
|
#ifdef _WIN64
|
|
id.setFromOldId((INT_PTR)_ttoi64(sInfo));
|
|
#else
|
|
id.setFromOldId((INT_PTR)_ttoi(sInfo));
|
|
#endif
|
|
|
|
xDataMap.SetAt(sKey, id, FALSE);
|
|
break;
|
|
}
|
|
case VT_R8: // 浮点
|
|
{
|
|
xDataMap.SetAt(sKey, __ttof(sInfo));
|
|
break;
|
|
}
|
|
case (VT_BYREF | VT_R8): // 点
|
|
{
|
|
if (StringToAcGePoint3d(sInfo, ptGe))
|
|
{
|
|
xDataMap.SetAt(sKey, ptGe);
|
|
}
|
|
break;
|
|
}
|
|
case (VT_BYREF | VT_R8 + 1): // cad变化点
|
|
{
|
|
if (StringToAcGePoint3d(sInfo, ptGe))
|
|
{
|
|
xDataMap.SetAt(sKey, ptGe, TRUE);
|
|
}
|
|
break;
|
|
}
|
|
case (VT_BYREF | VT_R8 + 2): // 向量
|
|
{
|
|
if (StringToAcGeVector3d(sInfo, vt))
|
|
{
|
|
sKey.Replace(DIF_VT_PT, _T(" "));
|
|
sKey.TrimRight();
|
|
xDataMap.SetAt(sKey, vt);
|
|
}
|
|
break;
|
|
}
|
|
case (VT_BYREF | VT_R8 + 3): // 变化向量
|
|
{
|
|
if (StringToAcGeVector3d(sInfo, vt))
|
|
{
|
|
sKey.Replace(DIF_VT_PT, _T(" "));
|
|
sKey.TrimRight();
|
|
xDataMap.SetAt(sKey, vt, TRUE);
|
|
}
|
|
break;
|
|
}
|
|
case (VT_BYREF | VT_R8 + 4): //矩阵
|
|
{
|
|
memset(&xDat, 0, sizeof(XData));
|
|
xDat.npszLen = sInfo.GetLength() + 1;
|
|
xDat.pszVal = new TCHAR[xDat.npszLen];
|
|
_tcscpy(xDat.pszVal, sInfo);
|
|
xDataMap.SetAt(sKey, xDat);
|
|
delete[] xDat.pszVal;
|
|
break;
|
|
}
|
|
case VT_BSTR: // 字符串
|
|
{
|
|
xDataMap.SetAt(sKey, sInfo);
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//按照常规处理
|
|
xDataMap.SetAt(pszKey, iIndex, sText);
|
|
bSuccess = TRUE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//按照常规处理
|
|
xDataMap.SetAt(pszKey, iIndex, sText);
|
|
bSuccess = TRUE;
|
|
}
|
|
}
|
|
return bSuccess;
|
|
}
|
|
|
|
BOOL AecXDataMap::SetAt(LPCTSTR pszKey, const AcDbObjectId& id, BOOL bIsSoft)
|
|
{
|
|
if (pszKey != NULL)
|
|
{
|
|
XData xdata;
|
|
memset(&xdata, 0, sizeof(xdata));
|
|
xdata.nVt = VT_UI4;
|
|
if (!bIsSoft) xdata.nVt = VT_UI8;
|
|
xdata.nVal = id.asOldId();
|
|
It it = m_xData.find(pszKey);
|
|
if (it != m_xData.end())
|
|
{
|
|
(*it).second = xdata;
|
|
}
|
|
else
|
|
{
|
|
std::pair<CString, XData> pa(pszKey, xdata);
|
|
m_xData.insert(pa);
|
|
}
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::SetAt(LPCTSTR pszKey, const XData& xData)
|
|
{
|
|
if (pszKey != NULL)
|
|
{
|
|
It it = m_xData.find(pszKey);
|
|
if (it != m_xData.end()) //找到
|
|
{
|
|
if ((*it).second.nVt == xData.nVt) //判断类型相同
|
|
{
|
|
if ((*it).second.nVt == VT_BSTR ||
|
|
(*it).second.nVt == (VT_BYREF | VT_R8 + 4)) //字符串特殊处理
|
|
{
|
|
// 重新分配空间赋值
|
|
if (xData.npszLen > 0 && xData.pszVal != NULL)
|
|
{
|
|
if ((*it).second.npszLen > 0 && (*it).second.pszVal != NULL) //清空原来的
|
|
delete[](*it).second.pszVal;
|
|
|
|
(*it).second = xData;
|
|
(*it).second.pszVal = new TCHAR[xData.npszLen];
|
|
memset((*it).second.pszVal, 0, xData.npszLen);
|
|
_tcscpy((*it).second.pszVal, xData.pszVal);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
(*it).second = xData;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (xData.nVt == VT_BSTR ||
|
|
xData.nVt == (VT_BYREF | VT_R8 + 4))
|
|
{
|
|
SetAt(pszKey, xData.pszVal);
|
|
}
|
|
else
|
|
{
|
|
std::pair<CString, XData> pa(pszKey, xData);
|
|
m_xData.insert(pa);
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::GetAt(LPCTSTR pszKey, XData& xData)
|
|
{
|
|
if (pszKey != NULL)
|
|
{
|
|
std::map<CString, XData>::const_iterator it;
|
|
if ((it = m_xData.find(pszKey)) != m_xData.end())
|
|
{
|
|
xData = (*it).second;
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::GetAt(LPCTSTR pszKey, int& nVal) const
|
|
{
|
|
if (pszKey != NULL)
|
|
{
|
|
std::map<CString, XData>::const_iterator it;
|
|
if ((it = m_xData.find(pszKey)) != m_xData.end())
|
|
{
|
|
XData xdata = (*it).second;
|
|
|
|
if (xdata.nVt == VT_I4)
|
|
{
|
|
nVal = (int)xdata.nVal;
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::GetAt(LPCTSTR pszKey, double& dVal) const
|
|
{
|
|
if (pszKey != NULL)
|
|
{
|
|
std::map<CString, XData>::const_iterator it;
|
|
if ((it = m_xData.find(pszKey)) != m_xData.end())
|
|
{
|
|
XData xdata = (*it).second;
|
|
|
|
if (xdata.nVt == VT_R8)
|
|
{
|
|
dVal = xdata.dVal[0];
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::GetAt(LPCTSTR pszKey, AcGeDoubleArray& arVal) const
|
|
{
|
|
arVal.setLogicalLength(0);
|
|
if (pszKey != NULL)
|
|
{
|
|
CString sSubKey;
|
|
double dVal;
|
|
|
|
int nIndex = 0;
|
|
sSubKey.Format(_T("%s%d"), pszKey, nIndex++);
|
|
while (GetAt(sSubKey, dVal))
|
|
{
|
|
arVal.append(dVal);
|
|
sSubKey.Format(_T("%s%d"), pszKey, nIndex++);
|
|
}
|
|
}
|
|
|
|
return (arVal.length() > 0);
|
|
}
|
|
BOOL AecXDataMap::GetAt(LPCTSTR pszKey, AcGeVector3d& vt) const
|
|
{
|
|
/*
|
|
由于设置向量是将键值pszkey后增加字符串"$vector3d",
|
|
故获取向量时在键值pszkey后增加字符串"$vector3d"
|
|
*/
|
|
if (pszKey != NULL)
|
|
{
|
|
CString sTmpKey = pszKey;
|
|
sTmpKey += DIF_VT_PT;
|
|
std::map<CString, XData>::const_iterator it;
|
|
if ((it = m_xData.find(sTmpKey)) != m_xData.end())
|
|
{
|
|
XData xdata = (*it).second;
|
|
|
|
if ((xdata.nVt == (VT_BYREF | VT_R8) + 2)
|
|
|| (xdata.nVt == ((VT_BYREF | VT_R8) + 3)))
|
|
{
|
|
vt.x = xdata.dVal[0];
|
|
vt.y = xdata.dVal[1];
|
|
vt.z = xdata.dVal[2];
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::GetAt(LPCTSTR pszKey, AcGePoint3d& ptGe) const
|
|
{
|
|
if (pszKey != NULL)
|
|
{
|
|
std::map<CString, XData>::const_iterator it;
|
|
if ((it = m_xData.find(pszKey)) != m_xData.end())
|
|
{
|
|
XData xdata = (*it).second;
|
|
|
|
if ((xdata.nVt == (VT_BYREF | VT_R8))
|
|
|| (xdata.nVt == (VT_BYREF | VT_R8 + 1)))
|
|
{
|
|
ptGe.x = xdata.dVal[0];
|
|
ptGe.y = xdata.dVal[1];
|
|
ptGe.z = xdata.dVal[2];
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::GetAt(LPCTSTR pszKey, AcGePoint3dArray& arPt) const
|
|
{
|
|
arPt.setLogicalLength(0);
|
|
if (pszKey != NULL)
|
|
{
|
|
CString sSubKey;
|
|
AcGePoint3d pt;
|
|
|
|
int nIndex = 0;
|
|
sSubKey.Format(_T("%s%d"), pszKey, nIndex++);
|
|
while (GetAt(sSubKey, pt))
|
|
{
|
|
arPt.append(pt);
|
|
sSubKey.Format(_T("%s%d"), pszKey, nIndex++);
|
|
}
|
|
}
|
|
|
|
return (arPt.length() > 0);
|
|
}
|
|
|
|
BOOL AecXDataMap::GetAt(LPCTSTR pszKey, CString &sValue) const
|
|
{
|
|
if (pszKey != NULL)
|
|
{
|
|
std::map<CString, XData>::const_iterator it;
|
|
if ((it = m_xData.find(pszKey)) != m_xData.end())
|
|
{
|
|
XData xdata = (*it).second;
|
|
|
|
if (xdata.nVt == VT_BSTR ||
|
|
xdata.nVt == (VT_BYREF | VT_R8 + 4))
|
|
{
|
|
sValue = xdata.pszVal;
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::GetAt(LPCTSTR pszKey, AcDbObjectId& id) const
|
|
{
|
|
if (pszKey != NULL)
|
|
{
|
|
std::map<CString, XData>::const_iterator it;
|
|
if ((it = m_xData.find(pszKey)) != m_xData.end())
|
|
{
|
|
XData xdata = (*it).second;
|
|
|
|
if (xdata.nVt == VT_UI4 ||
|
|
xdata.nVt == VT_UI8)
|
|
{
|
|
id.setFromOldId(xdata.nVal);
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::HasKey(LPCTSTR pszKey, int& nVt)
|
|
{
|
|
if (pszKey != NULL)
|
|
{
|
|
CString sTmpKey = pszKey;
|
|
sTmpKey += DIF_VT_PT;
|
|
|
|
if (m_xData.find(pszKey) != m_xData.end())
|
|
{
|
|
XData xdata = m_xData[pszKey];
|
|
nVt = xdata.nVt;
|
|
return TRUE;
|
|
}
|
|
else if (m_xData.find(sTmpKey) != m_xData.end())
|
|
{
|
|
XData xdata = m_xData[sTmpKey];
|
|
nVt = xdata.nVt;
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void AecXDataMap::Empty()
|
|
{
|
|
m_xData.clear();
|
|
}
|
|
|
|
BOOL AecXDataMap::RemoveAt(LPCTSTR pszKey)
|
|
{
|
|
if (pszKey != NULL)
|
|
{
|
|
CString sTmpKey = pszKey;
|
|
sTmpKey += DIF_VT_PT;
|
|
It it = m_xData.find(pszKey);
|
|
It it1 = m_xData.find(sTmpKey);
|
|
if (it != m_xData.end())
|
|
{
|
|
if ((*it).second.nVt == VT_BSTR ||
|
|
(*it).second.nVt == (VT_BYREF | VT_R8 + 4))
|
|
{
|
|
if ((*it).second.npszLen > 0 && (*it).second.pszVal != NULL)
|
|
{
|
|
delete[](*it).second.pszVal;
|
|
}
|
|
(*it).second.pszVal = NULL;
|
|
}
|
|
m_xData.erase(it);
|
|
//m_xData.clear();
|
|
return TRUE;
|
|
}
|
|
else if (it1 != m_xData.end())
|
|
{
|
|
if ((*it1).second.nVt == VT_BSTR ||
|
|
(*it1).second.nVt == (VT_BYREF | VT_R8 + 4))
|
|
{
|
|
if ((*it1).second.pszVal != NULL)
|
|
{
|
|
delete[](*it1).second.pszVal;
|
|
}
|
|
(*it1).second.pszVal = NULL;
|
|
}
|
|
m_xData.erase(it1);
|
|
//m_xData.clear();
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL AecXDataMap::RemoveAt(LPCTSTR pszKey, int nIndex)
|
|
{
|
|
if (pszKey != NULL)
|
|
{
|
|
CString sKey;
|
|
sKey.Format(_T("%s_%d"), pszKey, nIndex);
|
|
return RemoveAt(sKey);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
std::map<CString, XData>::iterator AecXDataMap::Begin()
|
|
{
|
|
return m_xData.begin();
|
|
}
|
|
|
|
BOOL AecXDataMap::GetNext(It& it, XData& xData)
|
|
{
|
|
if (it != m_xData.end())
|
|
{
|
|
xData = (*it).second;
|
|
++it;
|
|
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
std::map<CString, XData>::iterator AecXDataMap::End()
|
|
{
|
|
return m_xData.end();
|
|
}
|
|
|
|
BOOL AecXDataMap::Write(CFile* pFileOut, BOOL bWriteUserData)
|
|
{
|
|
CString sTemp = MAP_BLOCK_BEGIN;
|
|
_bstr_t bst((LPCTSTR)sTemp);
|
|
std::string str;
|
|
str.append((const char*)bst);
|
|
std::string str2 = Base64::Encode(str);
|
|
pFileOut->Write(str2.c_str(), strlen(str2.c_str()));
|
|
|
|
XData xdata;
|
|
int nVt = -1;
|
|
AcGePoint3d ptVal;
|
|
AcGeVector3d vt;
|
|
AcDbSoftPointerId id;
|
|
int nSize = 0;
|
|
CString sText, sVal;
|
|
|
|
if (bWriteUserData)
|
|
{
|
|
CMapStringToString mapStr2Str;
|
|
for (int i = 0; i < 1000; i++) //1000条用户数据
|
|
{
|
|
sText.Format(_T("user%d"), i);
|
|
if (GetAt(sText, sVal))
|
|
{
|
|
mapStr2Str.SetAt(sText, sVal);
|
|
}
|
|
}
|
|
|
|
nSize = mapStr2Str.GetCount();
|
|
pFileOut->Write(&nSize, sizeof(int));
|
|
|
|
for (POSITION ps = mapStr2Str.GetStartPosition(); ps != NULL;)
|
|
{
|
|
mapStr2Str.GetNextAssoc(ps, sText, sVal);
|
|
|
|
bst = (LPCTSTR)sText;
|
|
|
|
//key
|
|
nSize = strlen((const char*)bst);
|
|
pFileOut->Write(&nSize, sizeof(int));
|
|
pFileOut->Write((const char*)bst, nSize);
|
|
|
|
//vt
|
|
nVt = VT_BSTR;
|
|
pFileOut->Write(&nVt, sizeof(int));
|
|
|
|
//val
|
|
bst = (LPCTSTR)sVal;
|
|
nSize = strlen((const char*)bst);
|
|
pFileOut->Write(&nSize, sizeof(int));
|
|
pFileOut->Write((const char*)bst, nSize);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//多少个
|
|
nSize = m_xData.size();
|
|
pFileOut->Write(&nSize, sizeof(int));
|
|
|
|
typedef std::map<CString, XData>::const_iterator It;
|
|
for (It it = m_xData.begin(); it != m_xData.end(); ++it)
|
|
{
|
|
xdata = (*it).second;
|
|
nVt = xdata.nVt;
|
|
|
|
sText = (*it).first;
|
|
bst = (LPCTSTR)sText;
|
|
|
|
//key
|
|
nSize = strlen((const char*)bst);
|
|
pFileOut->Write(&nSize, sizeof(int));
|
|
pFileOut->Write((const char*)bst, nSize);
|
|
|
|
//vt
|
|
pFileOut->Write(&nVt, sizeof(int));
|
|
|
|
switch (nVt)
|
|
{
|
|
case VT_I4: // 整型
|
|
pFileOut->Write(&xdata.nVal, sizeof(int));
|
|
break;
|
|
case VT_UI4:
|
|
pFileOut->Write(&xdata.nVal, sizeof(int));
|
|
break;
|
|
case VT_UI8:
|
|
pFileOut->Write(&xdata.nVal, sizeof(int));
|
|
break;
|
|
case VT_R8: // 浮点
|
|
pFileOut->Write(&xdata.dVal[0], sizeof(double));
|
|
break;
|
|
case (VT_BYREF | VT_R8): // 点
|
|
case (VT_BYREF | VT_R8 + 1):
|
|
pFileOut->Write(xdata.dVal, sizeof(double) * 3);
|
|
break;
|
|
case (VT_BYREF | VT_R8 + 2): // 向量
|
|
case (VT_BYREF | VT_R8 + 3):
|
|
pFileOut->Write(xdata.dVal, sizeof(double) * 3);
|
|
break;
|
|
case (VT_BYREF | VT_R8 + 4): //矩阵
|
|
{
|
|
nSize = (int)xdata.npszLen;
|
|
pFileOut->Write(&nSize, sizeof(int));
|
|
pFileOut->Write(xdata.pszVal, nSize);
|
|
}
|
|
break;
|
|
case VT_BSTR: // 字符串
|
|
{
|
|
bst = xdata.pszVal;
|
|
nSize = strlen((const char*)bst);
|
|
pFileOut->Write(&nSize, sizeof(int));
|
|
pFileOut->Write((const char*)bst, nSize);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
sTemp = MAP_BLOCK_END;
|
|
bst = (LPCTSTR)sTemp;
|
|
str = std::string();
|
|
str.append((const char*)bst);
|
|
str2 = Base64::Encode(str);
|
|
pFileOut->Write(str2.c_str(), strlen(str2.c_str()));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL AecXDataMap::Read(CFile* pFileOut, BOOL bWriteUserData)
|
|
{
|
|
CString sTemp = MAP_BLOCK_BEGIN;
|
|
_bstr_t bst((LPCTSTR)sTemp);
|
|
std::string str;
|
|
str.append((const char*)bst);
|
|
std::string str2 = Base64::Encode(str);
|
|
|
|
char* pszBuf = new char[str2.length() + 1];
|
|
memset(pszBuf, 0, str2.length() + 1);
|
|
pFileOut->Read(pszBuf, str2.length());
|
|
|
|
int nCount = 0;
|
|
pFileOut->Read(&nCount, sizeof(int));
|
|
|
|
int nLen = 0;
|
|
for (int i = 0; i < nCount; i++)
|
|
{
|
|
pFileOut->Read(&nLen, sizeof(int));
|
|
if (nLen > 0)
|
|
{
|
|
char* pszKey = new char[nLen + 1];
|
|
memset(pszKey, 0, nLen + 1);
|
|
pFileOut->Read(pszKey, nLen);
|
|
|
|
//VT
|
|
int nVt = VT_BSTR;
|
|
pFileOut->Read(&nVt, sizeof(int));
|
|
|
|
nLen = 0;
|
|
pFileOut->Read(&nLen, sizeof(int));
|
|
|
|
//KEY:VAL
|
|
char* pszVal = new char[nLen + 1];
|
|
memset(pszVal, 0, nLen + 1);
|
|
pFileOut->Read(pszVal, nLen);
|
|
|
|
CString sText = pszVal;
|
|
CString sKey = pszKey;
|
|
SetAt(sKey, sText);
|
|
|
|
delete[] pszKey;
|
|
delete[] pszVal;
|
|
}
|
|
}
|
|
delete[] pszBuf;
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL AecXDataMap::FormatDataMap(CStringArray& arItemLines)
|
|
{
|
|
BOOL bFind = FALSE;
|
|
CString sDNAType, sLine, sKey, sValue;
|
|
long nVt = 0, i = 0;
|
|
AcGePoint3d ptGe;
|
|
CStringArray arTexts;
|
|
AcGeMatrix3d xform;
|
|
|
|
while (i <= (arItemLines.GetSize() - 3))
|
|
{
|
|
sLine = arItemLines.GetAt(i);
|
|
|
|
if (sLine.CompareNoCase(MAP_BLOCK_BEGIN) == 0)
|
|
{
|
|
bFind = TRUE;
|
|
i += 1;
|
|
continue;
|
|
}
|
|
|
|
if (sLine.CompareNoCase(MAP_BLOCK_END) == 0)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (bFind)
|
|
{
|
|
//KEY
|
|
sKey = sLine;
|
|
|
|
//VT
|
|
nVt = _ttoi(arItemLines.GetAt(i + 1));
|
|
|
|
//VALUE
|
|
sValue = arItemLines.GetAt(i + 2);
|
|
|
|
AcDbSoftPointerId id;
|
|
AcDbHardPointerId idh;
|
|
|
|
switch (nVt)
|
|
{
|
|
case VT_I4: // 整型
|
|
SetAt(sKey, _ttoi(sValue));
|
|
break;
|
|
case VT_UI4:
|
|
#ifdef _WIN64
|
|
id.setFromOldId((Adesk::IntDbId)_ttoi64(sValue));
|
|
#else
|
|
id.setFromOldId(_ttoi(sValue));
|
|
#endif
|
|
SetAt(sKey, id);
|
|
break;
|
|
case VT_UI8:
|
|
#ifdef _WIN64
|
|
id.setFromOldId((Adesk::IntDbId)_ttoi64(sValue));
|
|
#else
|
|
id.setFromOldId(_ttoi(sValue));
|
|
#endif
|
|
SetAt(sKey, idh, FALSE);
|
|
break;
|
|
case VT_R8: // 浮点
|
|
SetAt(sKey, __ttof(sValue));
|
|
break;
|
|
case (VT_BYREF | VT_R8): // 点
|
|
StringToAcGePoint3d(sValue, ptGe);
|
|
SetAt(sKey, ptGe);
|
|
break;
|
|
case (VT_BYREF | VT_R8 + 1): // cad变化点
|
|
StringToAcGePoint3d(sValue, ptGe);
|
|
SetAt(sKey, ptGe, TRUE);
|
|
break;
|
|
case (VT_BYREF | VT_R8 + 2): // 向量
|
|
StringToAcGePoint3d(sValue, ptGe);
|
|
sKey.Replace(DIF_VT_PT, _T(" "));
|
|
sKey.TrimRight();
|
|
SetAt(sKey, ptGe.asVector());
|
|
break;
|
|
case (VT_BYREF | VT_R8 + 3): // cad变化向量
|
|
StringToAcGePoint3d(sValue, ptGe);
|
|
sKey.Replace(DIF_VT_PT, _T(" "));
|
|
sKey.TrimRight();
|
|
SetAt(sKey, ptGe.asVector(), TRUE);
|
|
break;
|
|
case (VT_BYREF | VT_R8 + 4): //矩阵
|
|
arTexts.RemoveAll();
|
|
Script2StringArray(sValue, _T(','), arTexts);
|
|
if (arTexts.GetSize() == 16)
|
|
{
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
for (int j = 0; j < 4; j++)
|
|
{
|
|
xform.entry[i][j] = __ttof(arTexts.GetAt(i * 4 + j));
|
|
}
|
|
}
|
|
}
|
|
SetAt(sKey, xform);
|
|
break;
|
|
case VT_BSTR: // 字符串
|
|
SetAt(sKey, sValue);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
i += 3;
|
|
}
|
|
else
|
|
{
|
|
i += 1;
|
|
}
|
|
}
|
|
return m_xData.empty() ? FALSE : TRUE;
|
|
} |