//把一层设置为OFF or ON
void CArxHelper::SetOneLayer(const TCHAR *name,int flag,bool YN)
//flag 1:isoff 2:isfrozen 3:islocked
{
AcDbLayerTable *pLayerTable;
acdbCurDwg()->getLayerTable(pLayerTable,AcDb::kForRead);
if(!pLayerTable->has(name))
{
pLayerTable->close();
return;
}
AcDbObjectId id;
pLayerTable->getAt(name,id);
AcDbLayerTableRecord *pLayerTableRecord;
acdbOpenObject(pLayerTableRecord,id,AcDb::kForWrite);
switch(flag)
{
case 1:
pLayerTableRecord->setIsOff(YN);
break;
case 2:
pLayerTableRecord->setIsFrozen(YN);
break;
case 3:
pLayerTableRecord->setIsLocked(YN);
break;
}
pLayerTableRecord->close();
pLayerTable->close();
}
bool Additional_Class::FindLayer( CString LaylerName )
{
int n = 0;//判断是否找到图层
//////////////////////////////////////////////////////////////////////////
AcDbLayerTable *pLayerTbl;
acdbHostApplicationServices()->workingDatabase()
->getSymbolTable(pLayerTbl, AcDb::kForWrite);
// 建立图层遍历器
AcDbLayerTableIterator *pLayerIterator;
pLayerTbl->newIterator(pLayerIterator);
//
AcDbLayerTableRecord *pLayerTableRcd;
ACHAR *pLtName;
ACHAR *pLtNameTT;
CString pLtNameStr;
for (; !pLayerIterator->done(); pLayerIterator->step())
{
pLayerIterator->getRecord(pLayerTableRcd, AcDb::kForWrite);
pLayerTableRcd->getName(pLtName);
pLayerTableRcd->close();
pLtNameStr = pLtName;
if (pLtNameStr == LaylerName)
{
return true;
}
else
{
free(pLtName);
}
}
return false;
}
void ModifyLayerProp()
{
CString strLayerName(_T("NewLayer"));
AcDbLayerTable* pLayerTbl = NULL;
acdbHostApplicationServices()->workingDatabase()->getLayerTable(pLayerTbl, AcDb::kForRead);
if (!pLayerTbl->has(strLayerName))
{
pLayerTbl->close();
acutPrintf(_T("\nNo existed layer:\"%s\"."), strLayerName);
return;
}
Acad::ErrorStatus es;
AcDbLayerTableRecord* pLayerTblRcd = NULL;
pLayerTbl->getAt(strLayerName, pLayerTblRcd, AcDb::kForWrite);
AcCmColor oldColor = pLayerTblRcd->color();
int nCurColor = oldColor.colorIndex();
int nNewColor = oldColor.colorIndex();
if (acedSetColorDialog(nNewColor, Adesk::kFalse, nCurColor))
{
AcCmColor color;
color.setColorIndex(nNewColor);
pLayerTblRcd->setColor(color);
acutPrintf(_T("\nThe color of layer:\"%s\" has modified!"), strLayerName);
}
pLayerTblRcd->close();
pLayerTbl->close();
}
void Additional_Class::SetLayerIsOff( CString strLayerName)
{
AcDbLayerTable *pLayTbl = NULL;
acdbCurDwg()->getLayerTable(pLayTbl, AcDb::kForWrite);
if(!pLayTbl->has(strLayerName))
{
pLayTbl->close(); //该图层不存在
return;
}
AcDbLayerTableRecord *pLayTblRec = NULL;
AcDbObjectId objId;
pLayTbl->getAt(strLayerName, pLayTblRec, AcDb::kForWrite);
pLayTbl->close();
//pLayTblRec->isInUse();
if (pLayTblRec==NULL)
{
return;
}
bool tempBool = pLayTblRec->isOff();
if (tempBool == false)
{
pLayTblRec->setIsOff(true);
}
else
{
pLayTblRec->setIsOff(false);
}
pLayTblRec->close();
return;
}
Acad::ErrorStatus TWArxLayerMan::Init()
{
AcDbDatabase* pDb = GetWorkingDB();
Acad::ErrorStatus es = Acad::eOk;
AcDbLayerTable* pLayerTb = NULL;
es = pDb->getLayerTable( pLayerTb,AcDb::kForRead );
if( pLayerTb == NULL ) return es;
pLayerTb->close();
AcDbLayerTableIterator* pIte = NULL;
es = pLayerTb->newIterator( pIte );
if( pIte == NULL ) return es;
m_vLayers.clear();
for ( pIte->start(); !pIte->done(); pIte->step())
{
AcDbObjectId Id;
es = pIte->getRecordId( Id );
if( es != Acad::eOk ) continue;
m_vLayers.push_back( Id );
}
TWFreePtr( pIte );
return es;
}
// This function creates a new AcDbLayerTableRecord, fills
// it in, and adds it to the layer table
//
// THE FOLLOWING CODE APPEARS IN THE SDK DOCUMENT.
//
void
addLayer()
{
AcDbLayerTable *pLayerTbl;
acdbHostApplicationServices()->workingDatabase()
->getSymbolTable(pLayerTbl, AcDb::kForWrite);
if (!pLayerTbl->has(_T("ASDK_TESTLAYER"))) {
AcDbLayerTableRecord *pLayerTblRcd
= new AcDbLayerTableRecord;
pLayerTblRcd->setName(_T("ASDK_TESTLAYER"));
pLayerTblRcd->setIsFrozen(0);// layer to THAWED
pLayerTblRcd->setIsOff(0); // layer to ON
pLayerTblRcd->setVPDFLT(0); // viewport default
pLayerTblRcd->setIsLocked(0);// un-locked
AcCmColor color;
color.setColorIndex(1); // set color to red
pLayerTblRcd->setColor(color);
// For linetype, we need to provide the object ID of
// the linetype record for the linetype we want to
// use. First, we need to get the object ID.
//
AcDbLinetypeTable *pLinetypeTbl;
AcDbObjectId ltId;
acdbHostApplicationServices()->workingDatabase()
->getSymbolTable(pLinetypeTbl, AcDb::kForRead);
if ((pLinetypeTbl->getAt(_T("DASHED"), ltId))
!= Acad::eOk)
{
acutPrintf(_T("\nUnable to find DASHED")
_T(" linetype. Using CONTINUOUS"));
// CONTINUOUS is in every drawing, so use it.
//
pLinetypeTbl->getAt(_T("CONTINUOUS"), ltId);
}
pLinetypeTbl->close();
pLayerTblRcd->setLinetypeObjectId(ltId);
pLayerTbl->add(pLayerTblRcd);
pLayerTblRcd->close();
pLayerTbl->close();
} else {
pLayerTbl->close();
acutPrintf(_T("\nlayer already exists"));
}
}
AcDbObjectId CArxHelper::SetLayer(TCHAR* layerName)
{
AcDbObjectId layerId = NULL;
AcDbLayerTable *pLayerTbl;
acdbCurDwg()->getLayerTable(pLayerTbl,AcDb::kForWrite);
AcDbLayerTableIterator *pItr;
pLayerTbl->newIterator(pItr);
for(;!pItr->done();pItr->step())
{
AcDbLayerTableRecord *pLayer;
pItr->getRecord(pLayer,AcDb::kForRead);
TCHAR *str=NULL;
pLayer->getName(str);
if(_tcscmp(layerName,str)==0)
layerId=pLayer->id();
if(str!=NULL) delete []str;
pLayer->close();
if(layerId!=NULL)
break;
}
delete pItr;
pItr = NULL;
if(layerId==NULL)
{
AcDbLayerTableRecord *pLayerTblRcd=new AcDbLayerTableRecord();
Acad::ErrorStatus es = pLayerTblRcd->setName(layerName);
if (es != Acad::eOk)
pLayerTblRcd->setName(_T("0"));
pLayerTbl->add(layerId,pLayerTblRcd);
pLayerTblRcd->close();
}
pLayerTbl->close();
acdbCurDwg() ->setClayer(layerId);
return layerId;
}
void
AecUiPrEntitySet::getLockedLayers()
{
m_lockedLayerCache.setLogicalLength(0);
m_lockedLayerNames.RemoveAll();
if (m_filterLockedLayers == Adesk::kFalse)
return;
AcDbLayerTableRecord* layer;
const TCHAR* tmpName;
AcDbLayerTable* layTbl;
Acad::ErrorStatus es = acdbHostApplicationServices()->workingDatabase()->getSymbolTable(layTbl, AcDb::kForRead);
if (es == Acad::eOk) {
AcDbLayerTableIterator* tblIter;
if (layTbl->newIterator(tblIter) == Acad::eOk) {
for (; !tblIter->done(); tblIter->step()) {
es = tblIter->getRecord(layer, AcDb::kForRead);
if (es == Acad::eOk) {
if (layer->isLocked()) {
m_lockedLayerCache.append(layer->objectId());
es = layer->getName(tmpName);
if (es == Acad::eOk) {
m_lockedLayerNames.Add(tmpName);
}
else {
AEC_ASSERT(0);
m_lockedLayerNames.Add(_DNT(_T(""))); // have to keep balanced
}
}
layer->close();
}
}
delete tblIter;
}
else {
AEC_ASSERT(0);
}
layTbl->close();
}
}
//-------------------------------------------------------------------------------------------
//
// 功能： 向层表中添加记录（创建新层)
//
//
// 作者：Qin H.X.
//
// 日期：200709
//
// 历史：无
//
//----------------------------------------------------------------------------------------------
// - CGDCH03.AddLayer command (do not rename)
static void CGDCH03AddLayer(void)
{
//先声明一个空的层表指针
AcDbLayerTable *pLayerTbl;
//通过当前图形数据库获取层表对象指针
//打开层表为写入状态
acdbHostApplicationServices()->workingDatabase() ->getSymbolTable(pLayerTbl, AcDb::kForWrite);
//判断层是否已经存在
if(!pLayerTbl->has(_T("MyLayer"))) {
//新层表记录
AcDbLayerTableRecord *pLayerTblRcd= new AcDbLayerTableRecord;
pLayerTblRcd->setName(_T("MyLayer")); //设定图层名
pLayerTblRcd->setIsFrozen(0); // 图层解冻
pLayerTblRcd->setIsOff(0); // 打开图层
pLayerTblRcd->setVPDFLT(0); // 使用默认视口
pLayerTblRcd->setIsLocked(0); // 图层解锁
// AcCmColor是ACAD颜色管理类
AcCmColor color;
color.setColorIndex(1);
// 图层颜色为红色
pLayerTblRcd->setColor(color);
// 为给新图层设置线型，要得到线型表记录的ID。
// 以下的代码演示如何得到并操作记录ID
AcDbLinetypeTable *pLinetypeTbl;
AcDbObjectId ltId;
acdbHostApplicationServices()->workingDatabase()->getSymbolTable(pLinetypeTbl, AcDb::kForRead);
if ((pLinetypeTbl->getAt(_T("DASHED"), ltId))!= Acad::eOk) {
acutPrintf(_T("\n未发现DASHED线型使用CONTINUOUS线型"));
// 每一个不完全空的图形数据库的线型表中都有线型名为CONTINUOUS 的默认记录
pLinetypeTbl->getAt(_T("CONTINUOUS"), ltId);
}
pLinetypeTbl->close();
pLayerTblRcd->setLinetypeObjectId(ltId);
pLayerTbl->add(pLayerTblRcd);
pLayerTblRcd->close();
pLayerTbl->close();
} else {
pLayerTbl->close();
acutPrintf(_T("\n层已经存在"));
}
}
void CLayerTreeDlg::OnTvSelChanged(NMHDR* pNMHDR)
{
NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
// TODO: Add your control notification handler code here
TV_ITEM tvi = pNMTreeView->itemNew;
HTREEITEM hItem = tvi.hItem;
if(m_tree.ItemHasChildren(hItem))
{
return;
}
CString strLayerName = m_tree.GetItemText(hItem);
Acad::ErrorStatus es = Acad::eOk;
AcDbDatabase* pDB = acdbHostApplicationServices()->workingDatabase();
if (NULL == pDB)
return;
AcDbLayerTable *pLyTable = NULL;
AcDbLayerTableRecord *pLyRcd = NULL;
es = pDB->getSymbolTable(pLyTable,AcDb::kForRead); //获得当前数据库中层表指针
if ( es != Acad::eOk )
{
acutPrintf("\n获取LayerTable的时候发生错误，请稍后再试。\n");
return;
}
if ( !pLyTable->has(strLayerName) )
{
pLyTable->close();
return;
}
pLyTable->close();
SetCurrentLayer(strLayerName);
}
// 現在の状態を覚える
bool CAllLayerState::memorize(AcDbDatabase* pDb)
{
// レイヤテーブルの取得
AcDbLayerTable* pLayerTable = NULL;
if (pDb->getLayerTable(pLayerTable, AcDb::kForRead) != Acad::eOk)
return false;
AcDbLayerTableIterator* pIter;
pLayerTable->newIterator(pIter);
for (; !pIter->done(); pIter->step()) {
// レイヤを取得
AcDbObjectId idLayer;
pIter->getRecordId(idLayer);
CLayerState layerstate(idLayer);
push_back(layerstate);
}
delete pIter;
// 閉じとく
pLayerTable->close();
return true;
}
void CLayerTreeDlg::ShowLayer(HTREEITEM hItem, BOOL bShow)
{
CString sLayerName = m_tree.GetItemText(hItem);
HTREEITEM hChild = m_tree.GetNextItem(hItem,TVGN_CHILD);
// 只有树叶才有对应的图层
if (hChild == NULL)
{
ShowLayer(sLayerName, bShow);
//如果是面层，还要把它的填充图层打开
CString sHatchLayer;
sHatchLayer.Format("%s_填充",sLayerName);
bool hasHatch = false;
acDocManager->lockDocument(acDocManager->curDocument());
AcDbLayerTable * pLayerTbl = NULL;
Acad::ErrorStatus es =
acdbHostApplicationServices()->workingDatabase()->getSymbolTable(pLayerTbl,AcDb::kForRead);
if (pLayerTbl->has(sHatchLayer))
{
AcDbLayerTableRecord * pLayerTbRcd = NULL;
es = pLayerTbl->getAt(sHatchLayer,pLayerTbRcd,AcDb::kForWrite);
pLayerTbRcd->setIsOff(bShow == 0);
pLayerTbRcd->close();
hasHatch = true;
}
pLayerTbl->close();
acDocManager->unlockDocument(acDocManager->curDocument());
}
while(hChild != NULL)
{
ShowLayer(hChild, bShow);
hChild = m_tree.GetNextItem(hChild,TVGN_NEXT);
}
}
Acad::ErrorStatus
ArxDbgUtils::addNewLayer(LPCTSTR layerName, AcDbDatabase* db)
{
ASSERT(db != NULL);
// if layer already exists, then just return
AcDbLayerTable* layTbl;
Acad::ErrorStatus es = db->getSymbolTable(layTbl, AcDb::kForRead);
if (es != Acad::eOk)
return es;
if (layTbl->has(layerName)) {
layTbl->close();
return Acad::eOk;
}
// upgrade to write
es = layTbl->upgradeOpen();
if (es != Acad::eOk) {
ASSERT(0);
layTbl->close();
return es;
}
// make sure the name gets set ok
AcDbLayerTableRecord* newRec = new AcDbLayerTableRecord;
es = newRec->setName(layerName);
if (es != Acad::eOk) {
delete newRec;
layTbl->close();
return Acad::eInvalidInput;
}
// look up value for default linetype CONTINUOUS,
// AcDbLayerTableRecord doesn't set this automatically (at least it didn't in Sedona)
newRec->setLinetypeObjectId(db->continuousLinetype());
es = layTbl->add(newRec);
if (es != Acad::eOk)
delete newRec;
else
newRec->close();
layTbl->close();
return es;
}
static void CheakLayerExit(CString layerName,int colorIndx, AcDb::LineWeight lineWeigt)
{
//int colorIndx = 7; //默认的颜色为白色
//AcDb::LineWeight lineWeigt = AcDb::kLnWt000;
//lineWeigt = AcDb::kLnWt030;
AcDbLayerTable* pLayerTbl = NULL;
// 获取当前的数据库
AcDbDatabase*pDB=acdbHostApplicationServices()->workingDatabase();
// 因为要创建新的图层，所以先要以写的方式获取图层表
pDB->getSymbolTable(pLayerTbl,AcDb::kForWrite);
// 检查图层是否存在
if (!pLayerTbl->has(layerName)) {
// 初始化一个新的对象，并且设置它的属性
AcDbLayerTableRecord *pLayerTblRcd = new AcDbLayerTableRecord;
pLayerTblRcd->setName(layerName);
pLayerTblRcd->setIsFrozen(0); // 图层设置为THAWED（解冻的）
pLayerTblRcd->setIsOff(0); // 图层设置为ON(开着的)
pLayerTblRcd->setIsLocked(0); // 图层 un-locked(解锁的)
AcCmColor color;
color.setColorIndex(colorIndx); // 图层的颜色设置
pLayerTblRcd->setColor(color);
pLayerTblRcd->setLineWeight(lineWeigt);
// 增加一个新的图层到容器(表)中
pLayerTbl->add(pLayerTblRcd);
// 把新建的图层关闭(不要删除它)
pLayerTblRcd->close();
// 关闭容器(表)
pLayerTbl->close();
}
else {
// 如果这个图层已经存在，仅仅需要关闭表继续就是
AcDbLayerTableRecord *pLayerTblRcd;
pLayerTbl->getAt(layerName, pLayerTblRcd, AcDb::kForWrite);
AcCmColor color;
color.setColorIndex(colorIndx); // 图层的颜色设置
pLayerTblRcd->setColor(color);
pLayerTblRcd->setLineWeight(lineWeigt);
pLayerTblRcd->close();
pLayerTbl->close();
//acutPrintf(_T("\nMYLAYER already exists"));
}
}
Acad::ErrorStatus TWArxLayer::Create( OUT AcDbObjectId& IdLayer ) const
{
if( m_strName.IsEmpty() ) return Acad::eInvalidInput;
AcDbDatabase* pDb = GetWorkingDB();
Acad::ErrorStatus es = Acad::eKeyNotFound;
AcDbLayerTable* pLayerTb = NULL;
es = pDb->getLayerTable( pLayerTb,AcDb::kForRead );
if( pLayerTb == NULL ) return es;
es = pLayerTb->getAt( m_strName, IdLayer );
if( es == Acad::eOk )
{
pLayerTb->close();
return es;
}
es = pLayerTb->upgradeOpen();
AcDbLayerTableRecord* pLtr = new AcDbLayerTableRecord;
pLtr->setName( m_strName );
pLtr->setIsFrozen( m_bIsFrozen );
pLtr->setIsLocked( m_bIsLocked );
pLtr->setIsOff( m_bIsOff );
es = pLayerTb->add( IdLayer, pLtr );
pLayerTb->close();
if( es == Acad::eOk )
{
pLtr->close();
return es;
}
TWFreePtr( pLtr );
return es;
}
bool Additional_Class::Get_LayerLW( CString LayerName, double &Length, double &Width )
{
AcDbLayerTable *pLayerTbl = NULL;
acdbHostApplicationServices()->workingDatabase()->getSymbolTable(pLayerTbl,AcDb::kForRead);
if (!pLayerTbl->has(LayerName))
{
//acutPrintf("\n木有%s层！", LayerName);
//SetError("THERE ISN`T"+LayerName+"LATYER！", "Get_LayerLW");
pLayerTbl->close();
return false;
}
AcDbObjectId layerId;
pLayerTbl->getAt(LayerName, layerId);
pLayerTbl->close();
AcDbBlockTable *pBlkTbl = NULL;
////获得当前数据库块表
acdbHostApplicationServices()->workingDatabase()->getBlockTable(pBlkTbl,AcDb::kForWrite);
////获得模型空间块表记录
AcDbBlockTableRecord *pBlkTblRcd = NULL;
pBlkTbl->getAt(ACDB_MODEL_SPACE, pBlkTblRcd, AcDb::kForRead);
pBlkTbl->close();
////创建块表记录遍历器
AcDbBlockTableRecordIterator *pltr;
pBlkTblRcd->newIterator(pltr);
AcDbEntity *pEnt;
//AcDbEntityPointer pEnt_Ptr;
////AcDbObjectPointer<AcDbPolyline> pPolyLine_Ptr;
AcDbPolyline *pPolyLine = NULL;
AcDbObjectIdArray PolyLineID_List;
for (pltr->start(); !pltr->done(); pltr->step())
{
pltr->getEntity(pEnt, AcDb::kForRead);
// //pEnt_Ptr.acquire(pEnt);
if (pEnt->layerId()==layerId)
{
if (pEnt->isKindOf(AcDbPolyline::desc()))
{
pPolyLine = AcDbPolyline::cast(pEnt);
if (pPolyLine != NULL)
{
if (PolyLineIfRectangle(pPolyLine)==true)
{
PolyLineID_List.append(pPolyLine->objectId());
}
}
}
}
}
if (PolyLineID_List.length() >1)
{
acutPrintf(_T("Bom Error 1002\n"));// 有很多矩形
delete pltr;
pEnt->close();
pPolyLine->close();
pBlkTblRcd->close();
return false;
}
////pPolyLine.open(PolyLineID_List[0], AcDb::kForRead);
acdbOpenAcDbEntity(pEnt,PolyLineID_List[0], AcDb::kForRead); //error!
pPolyLine = AcDbPolyline::cast(pEnt);
Get_RectangleLW(pPolyLine, Length, Width);
pBlkTblRcd->close();
pPolyLine->close();
pEnt->close();
delete pltr;
return true;
}
bool Additional_Class::LaylerFilter( AcDbObjectIdArray &EntityID, bool(*Filter)(AcDbEntity*, AcDbObjectId&) )
{
// 遍历所有图层符合规则的实体返回ID列表
bool RunState = false;
AcDbObjectIdArray LayerID_Array;
vector<CString> LayerName_Array;
AcDbObjectIdArray tempIDList;
AcDbLayerTable *pLayerTbl;
AcDbLayerTableRecord *pLayerTblRcd;
acdbHostApplicationServices()->workingDatabase()->getLayerTable(pLayerTbl,AcDb::kForWrite);
AcDbLayerTableIterator *pltr;
pLayerTbl->newIterator(pltr); // 图层遍历器
ACHAR *layerName;
for (pltr->start(); !pltr->done(); pltr->step())
{
pltr->getRecord(pLayerTblRcd,AcDb::kForRead);
pLayerTblRcd->getName(layerName); // 得到图层名称
LayerName_Array.push_back(layerName);
//pLayerTbl->getAt(layerName,layerId); // 得到图层ID
//LayerID_Array.append(layerId); // 得到所有图层的ID列表
}
pLayerTbl->close();
pLayerTblRcd->close();
// 对每层实体进行遍历
for (int i=0; i<LayerName_Array.size(); i++)
{
RunState = LaylerFilter(LayerName_Array.at(i), EntityID, Filter);
}
//for (pltr->start(); !pltr->done(); pltr->step())
//{
// // 遍历所有图层开始
// pltr->getRecord(pLayerTblRcd,AcDb::kForRead);
// pLayerTblRcd->getName(layerName); // 得到图层名称
// pLayerTbl->getAt(layerName,layerId);
// for (pltrX->start(); !pltrX->done(); pltrX->step())
// {
// if(Acad::eOk ==pltrX->getEntity(pEnt, AcDb::kForRead, false))
// {
// if (200>Check_Entity(pEnt)>=100)
// {
// temp_layerId = pEnt->layerId();
// if (temp_layerId == layerId)
// {
// entityID = pEnt->objectId();
// if (Filter(pEnt, entityID) == true)
// {
// EntityID.append(entityID);
// }
// }
// }
// }
// }
//
// //RunState = LaylerFilter(layerName, tempIDList, Filter);
// //if (RunState == true)
// //{
// // for (int j = 0; j<tempIDList.length(); j++)
// // {
// // EntityID.append(tempIDList[j]);
// // }
// //}
//}
//pLayerTblRcd->close();
//pLayerTbl->close();
//pBlkTbl->close();
//pBlkTblRcd->close();
delete pltr;
return false;
}
bool Additional_Class::LaylerFilter( CString LaylerName, AcDbObjectIdArray &EntityID_Array, bool(*Filter)(AcDbEntity*, AcDbObjectId&) )
{
AcDbLayerTable *pLayerTbl;
acdbHostApplicationServices()->workingDatabase()->getLayerTable(pLayerTbl,AcDb::kForWrite);
if (false == (pLayerTbl->has(LaylerName)))
{
//acutPrintf("\n木有%s层！", LaylerName);
//SetError("THERE ISTN`T"+LaylerName+"LAYER！", "LaylerFilter");
pLayerTbl->close();
return false;
}
AcDbObjectId layerId;
pLayerTbl->getAt(LaylerName,layerId);
AcDbBlockTable *pBlkTbl;
//获得当前数据库块表
acdbHostApplicationServices()->workingDatabase()->getBlockTable(pBlkTbl,AcDb::kForWrite);
//获得模型空间块表记录
AcDbBlockTableRecord *pBlkTblRcd;
pBlkTbl->getAt(ACDB_MODEL_SPACE, pBlkTblRcd, AcDb::kForWrite);
//创建块表记录遍历器
AcDbBlockTableRecordIterator *pltr;
pBlkTblRcd->newIterator(pltr);
AcDbEntity *pEnt;
AcDbObjectId temp_layerId;
AcDbObjectId entityID;
//pBlkTblRcd->close();
//pBlkTbl->close();
//pLayerTbl->close();
for (pltr->start(); !pltr->done(); pltr->step())
{
if(Acad::eOk ==pltr->getEntity(pEnt, AcDb::kForRead, false))
{
//if (200>Check_Entity(pEnt)>=100)
//{
temp_layerId = pEnt->layerId();
if (temp_layerId == layerId) // 在当前图层中
{
entityID = pEnt->objectId();
if (Filter(pEnt, entityID) == true) // 符合过滤条件
{
EntityID_Array.append(entityID);
}
}
//}
pEnt->close();
}
}
int Len = EntityID_Array.length();
if (Len == 0)
{
pBlkTbl->close();
pLayerTbl->close();
pBlkTblRcd->close();
return false;
}
pBlkTbl->close();
pLayerTbl->close();
pBlkTblRcd->close();
return true;
}
//-----------------------------------------------------------------------------
void CLayerTreeDlg::OnNMClickLayerTree(NMHDR *pNMHDR, LRESULT *pResult)
{
// TODO: 在此添加控件通知处理程序代码
*pResult = 0;
UINT uFlag;
CPoint pt;
CString sSelLayer;
HTREEITEM SelRoot,ParRoot,NexRoot;
pt = CPoint(this->GetCurrentMessage()->pt);
m_tree.ScreenToClient(&pt);
SelRoot = m_tree.HitTest(pt,&uFlag);
if (NULL == SelRoot)
return;
if (uFlag & TVHT_ONITEMSTATEICON)
{
BOOL bChecked = m_tree.GetCheck(SelRoot);
//置反选中状态
SetTreeCheck(SelRoot, !bChecked);
//分析是否有必要对树枝进行调整
ParRoot = m_tree.GetParentItem(SelRoot);
while (ParRoot != NULL)
{
if (bChecked)
m_tree.SetCheck(ParRoot,FALSE);//当前处在被选择状态即将被取消选择
else
{
int k=0;//当前处在非选择状态即将有可能处于选择状态(标志位)
NexRoot=m_tree.GetNextItem(ParRoot,TVGN_CHILD);
if(NexRoot!=SelRoot)
{
if(!m_tree.GetCheck(NexRoot)) k=1;
}
if(k==0)
{
while(TRUE)
{
NexRoot=m_tree.GetNextItem(NexRoot,TVGN_NEXT);
if(NexRoot==NULL) break;
if(NexRoot==SelRoot) continue;
if(!m_tree.GetCheck(NexRoot))
{
k=1;
break;
}
}
}
if(k==0) m_tree.SetCheck(ParRoot);
}
ParRoot = m_tree.GetParentItem(ParRoot);
}
m_tree.SetCheck(SelRoot, bChecked);
ShowLayer(SelRoot, !bChecked);
// sendCommandToAutoCAD("redraw ");
}
else if(!m_tree.ItemHasChildren(SelRoot))
{
CString strLayerName = m_tree.GetItemText(SelRoot);
Acad::ErrorStatus es = Acad::eOk;
AcDbDatabase* pDB = acdbHostApplicationServices()->workingDatabase();
if (NULL == pDB)
return;
AcDbLayerTable *pLyTable = NULL;
AcDbLayerTableRecord *pLyRcd = NULL;
es = pDB->getSymbolTable(pLyTable,AcDb::kForRead); //获得当前数据库中层表指针
if ( es != Acad::eOk )
{
acutPrintf("\n获取LayerTable的时候发生错误，请稍后再试。\n");
return;
}
if ( !pLyTable->has(strLayerName) )
{
pLyTable->close();
return;
}
pLyTable->close();
SetCurrentLayer(strLayerName);
}
}
void DelLayer()
{
ACHAR szNewName[256];
_tcscpy(szNewName, _T("NewLayer"));
AcDbDatabase* pCurDb = acdbHostApplicationServices()->workingDatabase();
if (pCurDb == NULL)
{
acutPrintf(_T("\nError:Current database is NULL!"));
return;
}
bool bHas = false;
bool bDeled = false;
Acad::ErrorStatus es;
AcDbObjectId layerId;
AcDbLayerTable* pLayerTbl = NULL;
es = pCurDb->getLayerTable(pLayerTbl, AcDb::kForRead);
if (es == Acad::eOk)
{
if (pLayerTbl->has(szNewName))
{
AcDbLayerTableRecord* pLayerTblRcd = NULL;
AcDbLayerTableIterator* pLTblIter = NULL;
pLayerTbl->newIterator(pLTblIter);
for (pLTblIter->start(); !pLTblIter->done(); pLTblIter->step())
{
ACHAR* szLayerName = NULL;
pLTblIter->getRecord(pLayerTblRcd, AcDb::kForWrite, true);
if (pLayerTblRcd)
{
pLayerTblRcd->getName(szLayerName);
if (_tcscmp(szNewName, szLayerName) == 0)
{
es = pLayerTblRcd->erase(true);
if (es == Acad::eOk)
{
bDeled = true;
}
}
if (szLayerName)
{
ads_free(szLayerName);
}
pLayerTblRcd->close();
}
}
if (pLTblIter)
{
delete pLTblIter;
pLTblIter = NULL;
}
}
pLayerTbl->close();
}
if (bDeled)
{
acutPrintf(_T("\nErased the layer: \"%s\" successfully!"), szNewName);
}
else
{
acutPrintf(_T("\nFailed to erase the layer: \"%s\""), szNewName);
}
}
void ModifyEntityLayer()
{
int nRet = 0;
ads_name entName;
ads_point ptPick;
nRet = acedEntSel(_T("\nSelect an entity to change it's layer:"), entName, ptPick);
if (nRet != RTNORM)
{
acutPrintf(_T("\nFailed to select!"));
return;
}
Acad::ErrorStatus es;
AcDbObjectId objId;
AcDbEntity* pEnt = NULL;
acdbGetObjectId(objId, entName);
es = acdbOpenAcDbEntity(pEnt, objId, AcDb::kForWrite);
if (es != Acad::eOk)
{
acutPrintf(_T("\nFailed to open entity!"));
return;
}
ACHAR szNewName[255];
_tcscpy(szNewName, _T("NewLayer"));
bool bHasDone = false;
AcDbDatabase* pCurDb = acdbHostApplicationServices()->workingDatabase();
if (pCurDb == NULL)
{
acutPrintf(_T("\nError:Current database is NULL!"));
return;
}
AcDbObjectId layerId;
AcDbLayerTable* pLayerTbl = NULL;
es = pCurDb->getLayerTable(pLayerTbl, AcDb::kForRead);
if (es == Acad::eOk)
{
if (pLayerTbl->has(szNewName))
{
es = pLayerTbl->getAt(szNewName, layerId);
if (es == Acad::eOk)
{
es = pEnt->setLayer(layerId);
if (es == Acad::eOk)
{
bHasDone = true;
}
}
}
pLayerTbl->close();
}
pEnt->close();
if (bHasDone)
{
acutPrintf(_T("\nThe layer of entity has modified to layer:\"%s\""), szNewName);
}
else
{
acutPrintf(_T("\nFailed to modify the layer of entity to layer:\"%s\""), szNewName);
}
}
void CMyDlg::OnCreateLine()
{
// TODO: Add your control notification handler code here
acDocManager->lockDocument(curDoc());
int i;
int m, n;
char *buf = (char*)malloc(20);
AcDbObjectId LineId;
AcDbLine *pLine = NULL;
//块表
AcDbBlockTable *pTb = NULL;
//块表记录
AcDbBlockTableRecord *pTbr = NULL;
//层表
AcDbLayerTable *pLyr = NULL;
//层表记录
AcDbLayerTableRecord* pLyrr = NULL;
//图形数据库
AcDbDatabase *pDb = acdbHostApplicationServices()->workingDatabase();
Acad::ErrorStatus es;
CListCtrl *pListCtr = (CListCtrl *)GetDlgItem( IDC_LIST1 );
//设置随机数种子
srand(time(NULL));
//更新数据
UpdateData(TRUE);
m_VecSize += m_Edit5;
m_xVec.resize(m_VecSize);
m_yVec.resize(m_VecSize);
//acutPrintf("%d\n", m_Edit1);
es = pDb->getLayerTable(pLyr, AcDb::kForWrite); //以写的方式打开层表
es = pDb->getBlockTable(pTb, AcDb::kForRead); //以读的方式打开块表
es = pTb->getAt(ACDB_MODEL_SPACE, pTbr, AcDb::kForWrite);//以写的方式打开块表记录
//创建图层GalLineTest
if (!pLyr->has("GalLineTest"))
{
pLyrr = new AcDbLayerTableRecord; //创建层记录
pLyrr->setName("GalLineTest"); //设置名字
//pLyrr->setColor(color); //设置颜色
//pLyrr->setLineWeight(lnWt); //设置线宽
if (Acad::eOk != pLyr->add(pLyrr)) //添加该层记录到层表
{
//添加失败
delete pLyrr; //释放内存
pLyr->close(); //关闭层表
}
//关闭层表记录
pLyrr->close();
}
//关闭层表
pLyr->close();
//生成点坐标
for (i = 0; i < m_Edit5; ++i)
{
if ((m_Edit2 != 0) && (m_Edit4 != 0))
{
m_xVec[i] = rand() % m_Edit2 + m_Edit1;
m_yVec[i] = rand() % m_Edit4 + m_Edit3;
}
else
{
m_xVec[i] = 0;
m_yVec[i] = 0;
}
}
//遍历点坐标
for (m = 0; m < m_Edit5; ++m)
{
for (n = (m+1); n < m_Edit5; ++n)
{
if ((m_xVec[m] != m_xVec[n]) && (m_yVec[m] != m_yVec[n]))
{
AcGePoint3d ptStart(m_xVec[m], m_yVec[m], 0);
AcGePoint3d ptEnd(m_xVec[n], m_yVec[n], 0);
pLine = new AcDbLine(ptStart, ptEnd);
//pLine->setColor();
pLine->setLayer("GalLineTest");
//创建线段
es = pTbr->appendAcDbEntity(LineId, pLine);
if (Acad::eOk == es)
{
++m_lLineCnt;
}
//acutPrintf("%d\n", LineId);
sprintf(buf, "%d", LineId);
m_ListCtr.InsertItem(m_Row, buf);
buf = itoa(pLine->colorIndex(), buf, 10);
m_ListCtr.SetItemText(m_Row, 1, buf);
buf = itoa(LineLength(m_xVec[m], m_yVec[m],
m_xVec[n], m_yVec[n]), buf, 10);
m_ListCtr.SetItemText(m_Row, 2, buf);
++m_Row;
pLine->close(); //关闭实体
}
}
}
pTbr->close(); //关闭块表记录
pTb->close(); //关闭块表
acDocManager->unlockDocument(curDoc());
free(buf);
}
void Additional_Class::SetCurLayler( CString LaylerName )
{
AcDbDatabase *pCurDb = NULL;
pCurDb = acdbHostApplicationServices()->workingDatabase();
/*pCurDb->setClayer()*/
int n = 0;//判断是否找到图层
//////////////////////////////////////////////////////////////////////////
AcDbLayerTable *pLayerTbl;
acdbHostApplicationServices()->workingDatabase()
->getSymbolTable(pLayerTbl, AcDb::kForWrite);
// 建立图层遍历器
AcDbLayerTableIterator *pLayerIterator;
pLayerTbl->newIterator(pLayerIterator);
//
AcDbLayerTableRecord *pLayerTableRcd;
ACHAR *pLtName;
ACHAR *pLtNameTT;
CString pLtNameStr;
for (; !pLayerIterator->done(); pLayerIterator->step())
{
pLayerIterator->getRecord(pLayerTableRcd, AcDb::kForWrite);
pLayerTableRcd->getName(pLtName);
pLayerTableRcd->close();
pLtNameStr = pLtName;
if (pLtNameStr == LaylerName)
{
pCurDb->setClayer(pLayerTableRcd->id());
free(pLtName);
n = 1;//如果图层找到，则将n赋值为1
delete pLayerIterator;
pLayerTbl->close();
return;
}
else
{
free(pLtName);
}
}
if (n == 0)
{
// 新建图层
AcDbLayerTableRecord *pLayerTableRecordTT = new AcDbLayerTableRecord;
pLayerTableRecordTT->setName(LaylerName);
AcDbObjectId pLayerId;
pLayerTbl->add(pLayerId, pLayerTableRecordTT);
pLayerTableRecordTT->getName(pLtNameTT);
pLayerTableRecordTT->close();
//struct resbuf pResult;
//::acedGetVar(_T("CLAYER"),&pResult);//取得当前图层
//char *p = (LPSTR)(LPCTSTR)LaylerName;
//pResult.resval.rstring = pLtNameTT;
//int s=acedSetVar(_T("CLAYER"), &pResult);//将输入的图层设为当前层
//相当于命令 CLAYER LAYERNAME
//acutPrintf(_T("\nLinetype name is: %s"), pResult.resval.rstring);
//acutPrintf(_T("\nLinetype name is: %d"), s);
n = 1;//如果图层找到，则将n赋值为1
delete pLayerIterator;
pLayerTbl->close();
struct resbuf pResults;
::acedGetVar(_T("CLAYER"),&pResults);//取得当前图层
//pLtNameTT = "0";
pResults.resval.rstring = pLtNameTT;
::acedSetVar(_T("CLAYER"), &pResults);//将输入的图层设为当前层
free(pLtNameTT);
}
// acutPrintf(_T("\nLinetype name"));
// acutPrintf(_T("\nLinetype name is: %s"), pResult.resval.rstring);
}
void CreateLayer()
{
Acad::ErrorStatus es;
ACHAR szNewName[255];
_tcscpy(szNewName, _T("NewLayer"));
AcDbDatabase* pCurDb = acdbHostApplicationServices()->workingDatabase();
if (pCurDb == NULL)
{
acutPrintf(_T("\nError:Current database is NULL!"));
return;
}
AcDbLayerTableRecord* pNewLayer = new AcDbLayerTableRecord;
es = pNewLayer->setName(szNewName);
if (es != Acad::eOk)
{
acutPrintf(_T("\nFailed setName of the layer!"));
delete pNewLayer;
return;
}
AcCmColor cmColor;
cmColor.setColorIndex(1);
pNewLayer->setColor(cmColor);
pNewLayer->setIsFrozen(false);
pNewLayer->setIsOff(false);
pNewLayer->setVPDFLT(false);
pNewLayer->setIsLocked(false);
bool bStat = false;
AcDbLayerTable* pLayerTbl = NULL;
es = pCurDb->getLayerTable(pLayerTbl, AcDb::kForWrite);
if (es == Acad::eOk)
{
if (pLayerTbl->has(szNewName))
{
acutPrintf(_T("\nThe Layer \"%s\" has existed!"), szNewName);
delete pNewLayer;
}
else
{
es = pLayerTbl->add(pNewLayer);
if (es == Acad::eOk)
{
bStat = true;
pNewLayer->close();
}
else
{
acutPrintf(_T("\nFailed to add a new layer in LayerTable!"));
delete pNewLayer;
}
}
pLayerTbl->close();
}
if (bStat)
{
acutPrintf(_T("\nCreated the new layer: \"%s\" successfully!"), szNewName);
}
else
{
acutPrintf(_T("\nFailed to create the layer: \"%s\""), szNewName);
}
}
// This command demonstrates the use of kCleanup / kReuse flags
void AddEntityToLayer (AsdkHlrCollector &collector, ACHAR *layerName) {
//----- Check layer
if ( layerName != NULL && *layerName != ACRX_T('\0') ) {
AcDbDatabase *pDb =acdbHostApplicationServices ()->workingDatabase () ;
AcDbLayerTable *pLayerTable ;
pDb->getLayerTable (pLayerTable, AcDb::kForRead) ;
if ( !pLayerTable->has (layerName) ) {
AcDbLayerTableRecord *pLayerRecord =new AcDbLayerTableRecord ;
pLayerRecord->setName (layerName) ;
pLayerTable->upgradeOpen () ;
pLayerTable->add (pLayerRecord) ;
pLayerTable->downgradeOpen () ;
pLayerRecord->close () ;
pLayerTable->close () ;
applyCurDwgLayerTableChanges () ;
} else {
pLayerTable->close () ;
}
} else {
layerName =NULL ;
}
//----- Assign color to the resulting entities
//----- red for visible edges
//----- blue for non-visible edges
//----- yellow for internal edges
int n =collector.mOutputData.logicalLength () ;
for ( int i =0 ; i < n ; i++ ) {
AsdkHlrData *p =collector.mOutputData [i] ;
AcDbEntity *pEnt =p->getResultEntity () ;
AsdkHlrData::Visibility vis =p->getVisibility () ;
if ( vis == AsdkHlrData::kVisible ) {
pEnt->setColorIndex (1) ; //----- Read
} else if ( vis == AsdkHlrData::kInternallyHidden ) {
if ( p->getHlrVisibility () == AsdkHlrData::kVisible )
pEnt->setColorIndex (2) ; //----- Yellow
else
pEnt->setColorIndex (3) ; //----- Green
} else {
pEnt->setColorIndex (5) ; //----- Blue
}
if ( layerName != NULL )
pEnt->setLayer (layerName) ;
AcDbObjectId id ;
if ( postToDatabase (NULL, pEnt, id) != Acad::eOk ) {
acutPrintf (_T("Failed to add entity to current space.\n")) ;
break ;
}
//----- Entity originator path for block reference entities
AcDbObjectIdArray ids =p->getObjectIds () ;
if ( ids.logicalLength () > 0 ) {
acutPrintf (ACRX_T("\n%ld, "), pEnt->objectId ().asOldId ()) ;
for ( int j =0 ; j < ids.logicalLength () ; j++ ) {
acutPrintf (ACRX_T("%ld, "), ids.at (j).asOldId ()) ;
}
}
pEnt->close () ;
}
}
