Layer 图层

admin1

#include "StdAfx.h"
#include "LayerHelper.h"

const static int kNameLength = 260;

////////////////////////////////////////////////////////////////////
//////////////////////网上摘录代码--图层相关/////////////////////
////////////////////////////////////////////////////////////////////

static bool getAllLayers( AcDbObjectIdArray& arrLayers )
{

    AcDbLayerTable* layerTable ;
    Acad::ErrorStatus es ;

    //open the layertable in the current drawing
    if ( Acad::eOk !=  acdbHostApplicationServices()->workingDatabase()->getLayerTable( layerTable, AcDb::kForRead ) )
    {
        acutPrintf ( _T( "\nCouldn''t get the layer table" ) ) ;
        return false;
    }

    //create a new iterator
    AcDbLayerTableIterator* pLayerTableIterator ;
    if ( Acad::eOk != layerTable->newIterator ( pLayerTableIterator ) )
    {
        acutPrintf ( _T( "\nCouldn''t get a new layer table iterator" ) ) ;
        layerTable->close () ;
        return false ;
    }
    layerTable->close () ;
    AcDbObjectId layerId ;

    //iterate through the all layers and collect their ids
    for ( ; !pLayerTableIterator->done () ; pLayerTableIterator->step() )
    {
        if ( Acad::eOk != pLayerTableIterator->getRecordId( layerId ) )
        {
            acutPrintf( _T( "\nCannot get layers" ) );
            continue;
        }
        else
        {
            arrLayers.append( layerId );
        }
    }
    delete pLayerTableIterator;

    return true;

}

// Argument : AcDbDatabase* pDb
static Acad::ErrorStatus setCurLayer( const TCHAR* lpLayerName, AcDbDatabase* pDb )
{
    AcDbDatabase* pCurDb = pDb;
    if ( pCurDb == NULL )
        pCurDb = acdbHostApplicationServices() -> workingDatabase();
    // 使用了layertable记录指针，比较方便
    AcDbLayerTableRecordPointer spRecord( lpLayerName, pCurDb, AcDb::kForRead );
    Acad::ErrorStatus es = spRecord.openStatus();
    if ( es == Acad::eOk )
    {
        es = pCurDb -> setClayer( spRecord -> objectId() );
    }
    return es;
}


static AcDbObjectId createNewLayer( const CString& LayerName )
{
    // 获得当前图形数据库的符号表
    AcDbLayerTable* pLayerTable;
    acdbHostApplicationServices()->workingDatabase()->getSymbolTable( pLayerTable, AcDb::kForWrite );
    // 生成新的图层表记录
    AcDbLayerTableRecord* pLayerTableRecord = new AcDbLayerTableRecord;
    pLayerTableRecord->setName( LayerName ); // 设置图层名
    //pLayerTableRecord->setColor(LayerColor); // 设置图层颜色
    AcDbObjectId layerId;
    pLayerTable->add( layerId, pLayerTableRecord );
    // 关闭图层表和图层表记录
    pLayerTable->close();
    pLayerTableRecord->close();
    return layerId;
}

static AcDbObjectId addLayer( const TCHAR* LayerName,
                              const Adesk::Int16 LayerColor,
                              //const char* Linetype,
                              AcDbDatabase* pDb )
{
    if( pDb == NULL )
        pDb = acdbHostApplicationServices()->workingDatabase();

    // 装载线型
    /*pDb->loadLineTypeFile(Linetype,"acadiso.lin");
    AcDbObjectId LineTypeId=AddLineType(pDb,Linetype);*/

    AcDbLayerTable* pLayerTable = NULL;
    AcDbLayerTableRecord* pLayerRecord = NULL;
    AcDbObjectId LayerId = AcDbObjectId::kNull;
    if( Acad::eOk != pDb->getLayerTable( pLayerTable, AcDb::kForRead ) ) return false;

    if( pLayerTable->has( LayerName ) )
    {
        pLayerTable->getAt( LayerName, LayerId );
    }
    else
    {
        pLayerRecord = new AcDbLayerTableRecord;
        AcCmColor color;
        color.setColorIndex( LayerColor );
        pLayerRecord->setColor( color );
        //pLayerRecord->setLinetypeObjectId(LineTypeId);
        pLayerRecord->setName( LayerName );
        pLayerTable->add( LayerId, pLayerRecord );
        pLayerRecord->close();
    }
    pLayerTable->close();
    return LayerId;
}

static bool frozenLayer( const CString& layerName, bool isFrozen )
{
    AcDbDatabase* pDb = acdbHostApplicationServices()->workingDatabase();
    if( pDb == 0 ) return false;

    AcDbLayerTable* pLayerTable = NULL;
    if( Acad::eOk != pDb->getLayerTable( pLayerTable, AcDb::kForRead ) ) return false;

    AcDbLayerTableRecord* pLayerRecord = NULL;
    if( Acad::eOk != pLayerTable->getAt( layerName, pLayerRecord, AcDb::kForWrite ) )
    {
        pLayerTable->close();
        return false;
    }
    pLayerTable->close();

    pLayerRecord->setIsFrozen( isFrozen ); // 冻结/解冻
    pLayerRecord->close();

    return true;
}

static bool hiddenLayer( const CString& layerName, bool isOn )
{
    AcDbDatabase* pDb = acdbHostApplicationServices()->workingDatabase();
    if( pDb == 0 ) return false;

    AcDbLayerTable* pLayerTable = NULL;
    if( Acad::eOk != pDb->getLayerTable( pLayerTable, AcDb::kForRead ) ) return false;

    AcDbLayerTableRecord* pLayerRecord = NULL;
    if( Acad::eOk != pLayerTable->getAt( layerName, pLayerRecord, AcDb::kForWrite ) )
    {
        pLayerTable->close();
        return false;
    }
    pLayerTable->close();

    pLayerRecord->setIsHidden( isOn ); // 隐藏/显示
    pLayerRecord->close();

    return true;
}

static bool lockLayer( const CString& layerName, bool locked )
{
    AcDbDatabase* pDb = acdbHostApplicationServices()->workingDatabase();
    if( pDb == 0 ) return false;

    AcDbLayerTable* pLayerTable = NULL;
    if( Acad::eOk != pDb->getLayerTable( pLayerTable, AcDb::kForRead ) ) return false;

    AcDbLayerTableRecord* pLayerRecord = NULL;
    if( Acad::eOk != pLayerTable->getAt( layerName, pLayerRecord, AcDb::kForWrite ) )
    {
        pLayerTable->close();
        return false;
    }
    pLayerTable->close();

    pLayerRecord->setIsLocked( locked ); // 锁定/不锁定
    pLayerRecord->close();

    return true;
}

static bool offLayer( const CString& layerName, bool off )
{
    AcDbDatabase* pDb = acdbHostApplicationServices()->workingDatabase();
    if( pDb == 0 ) return false;

    AcDbLayerTable* pLayerTable = NULL;
    if( Acad::eOk != pDb->getLayerTable( pLayerTable, AcDb::kForRead ) ) return false;

    AcDbLayerTableRecord* pLayerRecord = NULL;
    if( Acad::eOk != pLayerTable->getAt( layerName, pLayerRecord, AcDb::kForWrite ) )
    {
        pLayerTable->close();
        return false;
    }
    pLayerTable->close();

    pLayerRecord->setIsOff( off ); // 关闭/打开
    pLayerRecord->close();

    return true;
}

static void renameLayerName( const CString& layerName, const CString& newLayerName )
{
    AcDbDatabase* pDb = acdbHostApplicationServices()->workingDatabase();
    if( pDb == 0 ) return /*false*/;

    AcDbLayerTable* pLayerTable = NULL;
    if( Acad::eOk != pDb->getLayerTable( pLayerTable, AcDb::kForRead ) ) return /*false*/;

    AcDbLayerTableRecord* pLayerRecord = NULL;
    if( Acad::eOk != pLayerTable->getAt( layerName, pLayerRecord, AcDb::kForWrite ) )
    {
        pLayerTable->close();
        return /*false*/;
    }
    pLayerTable->close();

    pLayerRecord->setName( newLayerName ); // 修改名称
    pLayerRecord->close();

    //return true;
}

void LayerHelper::SetCurrentLayer( const CString& layerName )
{
    // 图层不存在，则什么也不做，当前图层保持不变
    //if(!IsLayerExist(layerName)) return;

    setCurLayer( layerName, NULL );
}

CString LayerHelper::GetCurrentLayerName()
{
    AcDbObjectId layerId = acdbHostApplicationServices()->workingDatabase()->clayer();

    AcDbObject* pLayer;

    // 打开失败，则什么也不做，返回空字符串
    if ( Acad::eOk != acdbOpenObject( pLayer, layerId, AcDb::kForRead ) ) return _T( "" );

    const TCHAR* name;
    AcDbLayerTableRecord::cast( pLayer )->getName( name );
    pLayer->close();

    return name;
}

void LayerHelper::AddLayer( const CString& layerName )
{
    // 按照我的设想，还应该处理一些特殊的情况，例如
    // 字符串为空串""，字符串中包含非法字符'\t','\n',' '
    // 目前暂时不考虑这个问题

    // 图层已经存在
    if( IsLayerExist( layerName ) ) return;

    createNewLayer( layerName );
}

void LayerHelper::RemoveLayer( const CString& layerName )
{
    // 图层不存在
    if( !IsLayerExist( layerName ) ) return;

    // 图层为当前图层，不能删除
    if( IsCurrentLayer( layerName ) ) return;

    AcDbLayerTable* layerTable ;

    // 打开层表
    if ( Acad::eOk !=  acdbHostApplicationServices()->workingDatabase()->getLayerTable( layerTable, AcDb::kForWrite ) )
        return;

    // 判断层是否存在
    AcDbLayerTableRecord* pLayerTblRecord;
    // 打开层表记录失败（打开图层layerName）
    if( layerTable->getAt( layerName, pLayerTblRecord, AcDb::kForWrite ) != Acad::eOk )
    {
        layerTable->close();
        return;
    }

    // 删除图层
    pLayerTblRecord->erase( true );
    pLayerTblRecord->close();

    // 关闭层表
    layerTable->close();
}

bool LayerHelper::IsLayerExist( const CString& layerName )
{
    AcDbLayerTable* layerTable ;

    // 打开层表
    if ( Acad::eOk !=  acdbHostApplicationServices()->workingDatabase()->getLayerTable( layerTable, AcDb::kForRead ) )
        return false;

    // 判断层是否存在
    bool isExist = layerTable->has( layerName );

    // 关闭层表
    layerTable->close();

    return isExist;
}


bool LayerHelper::IsCurrentLayer( const CString& layerName )
{
    AcDbObjectId layerId = acdbHostApplicationServices()->workingDatabase()->clayer();

    AcDbObject* pLayer;

    // 打开失败，则什么也不做，返回
    if ( Acad::eOk != acdbOpenObject( pLayer, layerId, AcDb::kForRead ) ) return false;

    const TCHAR* name;
    AcDbLayerTableRecord::cast( pLayer )->getName( name );
    // 关闭图层对象
    pLayer->close();

    return ( layerName == name ); // 效率较差
}

bool LayerHelper::FrozenLayer( const CString& layerName, bool isFrozen )
{
    // 图层不存在
    if( !IsLayerExist( layerName ) ) return false;

    // 当前图层，不允许冻结
    if( IsCurrentLayer( layerName ) ) return false;

    return frozenLayer( layerName, isFrozen );
}

bool LayerHelper::HideLayer( const CString& layerName, bool isOn )
{
    // 图层不存在
    if( !IsLayerExist( layerName ) ) return false;

    // 当前图层，不允许隐藏
    if( IsCurrentLayer( layerName ) ) return false;

    return hiddenLayer( layerName, isOn );
}

bool LayerHelper::LockLayer( const CString& layerName, bool locked )
{
    // 图层不存在
    if( !IsLayerExist( layerName ) ) return false;

    // 当前图层，不允许隐藏
    if( IsCurrentLayer( layerName ) ) return false;

    return lockLayer( layerName, locked );
}

bool LayerHelper::OffLayer( const CString& layerName, bool off )
{
    // 图层不存在
    if( !IsLayerExist( layerName ) ) return false;

    // 当前图层，不允许隐藏
    if( IsCurrentLayer( layerName ) ) return false;

    return offLayer( layerName, off );
}

void LayerHelper::RenameLayer( const CString& layerName, const CString& newLayerName )
{
    // 图层名称为空不合理
    if( newLayerName.GetLength() == 0 ) return /*false*/;

    // 图层不存在
    if( !IsLayerExist( layerName ) ) return /*false*/;

    // 当前图层，不允许隐藏
    //if(IsCurrentLayer(layerName)) return false;

    renameLayerName( layerName, newLayerName );
}

/*
//put the Ids of all the entities on a certain layer in the array, "ents"
bool LayerHelper::GetAllEntitiesOnLayer(const CString& layerName, AcDbObjectIdArray &ents)
{
        Acad::ErrorStatus es;
        //construct a resbuffer to select all the entities on a layer
        struct resbuf eb1;
        TCHAR sbuf1[kNameLength]; // Buffers to hold string
        eb1.restype = 8;  // select based on layer name
        _tcscpy(sbuf1, layerName);
        eb1.resval.rstring = sbuf1;
        eb1.rbnext = NULL; // No other properties

        ads_name ss;
        if (RTNORM != acedSSGet(_T("X"), NULL, NULL, &eb1, ss ) )
                return false;
        long nEnts;

        //Iterate through the selection set, get all the entities' object Ids and
        //append them to the array, "ents"
        acedSSLength( ss, &nEnts );
        ents.setPhysicalLength(nEnts);
        for(int i = 0; i < nEnts; i++ ) {
                ads_name eName;
                acedSSName(ss, i, eName);
                AcDbObjectId id;
                acdbGetObjectId(id, eName);
                ents.append(id);
        }
        acedSSFree( ss );

        return true;
}
*/

bool LayerHelper::GetAllEntitiesOnLayer( const CString& layerName, AcDbObjectIdArray& ents )
{
    AcDbDatabase* pDB = acdbHostApplicationServices()->workingDatabase();
    AcDbBlockTable* pBlkTbl;
    pDB->getSymbolTable( pBlkTbl, AcDb::kForRead );

    AcDbBlockTableRecord* pBlkTblRcd;
    pBlkTbl->getAt( ACDB_MODEL_SPACE, pBlkTblRcd, AcDb::kForRead );
    pBlkTbl->close();

    AcDbBlockTableRecordIterator* pBlkTblRcdItr;
    pBlkTblRcd->newIterator( pBlkTblRcdItr );
    for ( pBlkTblRcdItr->start(); !pBlkTblRcdItr->done(); pBlkTblRcdItr->step() )
    {
        AcDbEntity* pEnt;
        if( Acad::eOk != pBlkTblRcdItr->getEntity( pEnt, AcDb::kForRead ) ) continue;

        if( layerName.CompareNoCase( pEnt->layer() ) == 0 )
        {
            ents.append( pEnt->objectId() );
        }
        pEnt->close();
    }
    delete pBlkTblRcdItr;

    pBlkTblRcd->close();

    return true;
}

void LayerHelper::DeleteAllEntitiesOnLayer( const CString& layerName )
{
    AcDbDatabase* pDB = acdbHostApplicationServices()->workingDatabase();
    AcDbBlockTable* pBlkTbl;
    pDB->getSymbolTable( pBlkTbl, AcDb::kForRead );

    AcDbBlockTableRecord* pBlkTblRcd;
    pBlkTbl->getAt( ACDB_MODEL_SPACE, pBlkTblRcd, AcDb::kForRead );
    pBlkTbl->close();

    AcDbBlockTableRecordIterator* pBlkTblRcdItr;
    pBlkTblRcd->newIterator( pBlkTblRcdItr );
    for ( pBlkTblRcdItr->start(); !pBlkTblRcdItr->done(); pBlkTblRcdItr->step() )
    {
        AcDbEntity* pEnt;
        if( Acad::eOk != pBlkTblRcdItr->getEntity( pEnt, AcDb::kForWrite ) ) continue;

        if( layerName.CompareNoCase( pEnt->layer() ) == 0 )
        {
            pEnt->erase( true );
        }
        pEnt->close();
    }
    delete pBlkTblRcdItr;

    pBlkTblRcd->close();
}

void LayerHelper::GetAllLayers( AcStringArray& layers )
{
    AcDbLayerTable* layerTable ;
    Acad::ErrorStatus es ;

    //open the layertable in the current drawing
    if ( Acad::eOk !=  acdbHostApplicationServices()->workingDatabase()->getLayerTable( layerTable, AcDb::kForRead ) )
    {
        //acutPrintf (_T("\nCouldn''t get the layer table")) ;
        return /*false*/;
    }

    //create a new iterator
    AcDbLayerTableIterator* pLayerTableIterator ;
    if ( Acad::eOk != layerTable->newIterator ( pLayerTableIterator ) )
    {
        acutPrintf ( _T( "\nCouldn''t get a new layer table iterator" ) ) ;
        layerTable->close () ;
        //return false ;
    }
    layerTable->close () ;
    AcDbObjectId layerId ;

    //iterate through the all layers and collect their ids
    for ( ; !pLayerTableIterator->done () ; pLayerTableIterator->step() )
    {
        AcDbLayerTableRecord* pRecord;
        if ( Acad::eOk != pLayerTableIterator->getRecord( pRecord, AcDb::kForRead ) )
        {
            //acutPrintf(_T("\nCannot get layers"));
            continue;
        }
        else
        {
            AcString str;
            pRecord->getName( str );
            layers.append( str );
        }
    }
    delete pLayerTableIterator;

    //return true;
}

LayerSwitch::LayerSwitch( const CString& layerName, bool createNewLayer )
{
    // 记录当前图层
    m_curLayer = LayerHelper::GetCurrentLayerName();
    acutPrintf( _T( "\n当前图层:【%s】" ), m_curLayer );

    if( LayerHelper::IsLayerExist( layerName ) )
    {
        LayerHelper::SetCurrentLayer( layerName );
    }
    else if( createNewLayer )
    {
        LayerHelper::AddLayer( layerName ); // 如果存在则不建立
        LayerHelper::SetCurrentLayer( layerName );
    }
}

LayerSwitch::~LayerSwitch()
{
    // 切换回原来的图层
    LayerHelper::SetCurrentLayer( m_curLayer );
}

jxmjg

  法拉利膜材作为一种高性能的建筑材料，在建筑、汽车及广告等多个领域有着广泛的应用。以下是对法拉利膜材型号、特点及优点的详细分析：
[img]http://www.mjgou.com/data/attachment/forum/202403/13/223041uiqmeujen4jjj6zv.jpg[/img]
[b]一、法拉利膜材型号[/b]
法拉利膜材有多种型号，包括但不限于以下几种：1302 S2 Flexlight Advanced：这是一种高性能IV型柔性复合膜材，以其卓越的透光性、耐久性和易维护性而受到青睐。942、1202 S2、1002 S2、902 S2、1212 S2、912 S2：这些型号同样属于法拉利膜材系列，各自具有不同的特性和适用范围，但具体特点需根据具体型号进一步分析。需要注意的是，法拉利膜材的型号可能随着产品更新换代而有所变化，具体型号及其特性请参考最新产品资料。
[img=860,1255]http://www.mjgou.com/data/attachment/forum/202403/13/223254bbblwlbvbvsbwlsl.jpg[/img]
[b]二、法拉利膜材特点[/b]
法拉利膜材的特点主要体现在以下几个方面：
1、高强度与耐用性：法拉利膜材采用高强度材料制成，具有良好的抗拉强度和撕裂强度，能够承受较大的外力作用而不易破损。耐用性强，能够在恶劣气候条件下保持稳定的性能，延长使用寿命。
2、透光性与美观性：部分型号如1302 S2 Flexlight Advanced具有高透光性，能够在保持室内光线充足的同时，提供清晰的视野。膜材表面平整光滑，色彩丰富多样，能够满足不同建筑和装饰需求，提升整体美观性。
3、轻质与灵活性：法拉利膜材重量较轻，便于运输和安装，能够降低施工成本和时间。膜材具有一定的柔韧性，能够适应各种复杂形状和结构的设计要求。
4、环保与可回收性：法拉利膜材符合环保要求，部分材料可回收利用，减少了对环境的影响。
[img]http://www.mjgou.com/data/attachment/forum/202403/13/223128owhn0099rrds5h5y.jpg[/img]
[b]三、法拉利膜材优点[/b]
法拉利膜材的优点主要体现在以下几个方面：
1、提升建筑性能：高强度与耐用性使得法拉利膜材能够提升建筑的稳定性和安全性，延长使用寿命。透光性与美观性使得建筑内部光线充足、视野开阔，同时提升整体美观度。
2、降低施工成本：轻质特性使得运输和安装成本降低，施工效率提高。膜材的柔韧性使得施工更加灵活多变，能够适应各种复杂地形和结构要求。
3、节能环保：部分材料可回收利用，符合环保要求，减少了对环境的影响。良好的透光性能够减少室内照明需求，降低能耗。
4、广泛应用领域：
法拉利膜材不仅适用于建筑领域（如体育设施、商业设施、文化设施、交通设施等），还广泛应用于汽车及广告领域（如高档车辆贴膜保护和装饰、广告招贴等），展现出其多功能的特性。

综上所述，法拉利膜材以其高强度、耐用性、透光性、美观性、轻质灵活性以及环保可回收性等优点，在建筑、汽车及广告等多个领域发挥着重要作用。具体型号的选择应根据实际需求和应用场景进行综合考虑。
[url=http://www.mjgou.com/forum-17-1.html][size=95109][color=Red]法拉利膜材中国代理商 - 膜结构网[/color][/size][/url]

耐弛膜中国代理

耐弛膜材，具有高性能、耐候性、耐久性等特性的膜材品牌或产品系列。以下是对这类膜材的详细介绍：
[b]一、品牌与类型[/b]
品牌：虽然直接以“耐弛”命名的品牌信息不明确，但我们可以将其视为一种高性能膜材的代表。
类型：耐弛膜材可能包括PVC膜材、PVDF膜材以及PTFE膜材等多种类型，这些材料在膜结构建筑、污水处理、空气净化等领域有广泛应用。
[b]二、产品特点[/b]
耐候性：耐弛膜材通常具有优异的耐候性，能够抵抗紫外线、高温、低温等极端天气条件的侵蚀，保持长久的色彩鲜艳和材料性能。
耐久性：材料强度高，抗拉、撕裂性能优异，能够承受各种外力的作用，延长使用寿命。
自洁性：部分耐弛膜材表面经过特殊处理，具有自洁功能，能够减少灰尘和污染物的附着，降低清洁成本。
化学稳定性：耐化学腐蚀性强，能够抵抗多种化学物质的侵蚀，保持材料的稳定性和功能性。
环保性：部分耐弛膜材为可回收材料，符合环保要求，有助于减少建筑垃圾和环境污染。
[b]三、应用领域[/b]
耐弛膜材广泛应用于多个领域，包括但不限于：
建筑领域：作为膜结构建筑的主要材料，用于体育场馆、展览馆、商业设施等建筑的屋顶和墙面覆盖。
污水处理：在污水处理厂中作为污水膜材使用，能够有效去除水中的悬浮物、有机物等污染物。
空气净化：在空气净化设备和系统中作为滤材使用，具有高效的过滤性能和耐化学性。
其他领域：如交通设施（如高速公路隔音屏）、工业设施（如化工厂、制药厂的防腐蚀覆盖材料）等。
[b]四、品牌合作与研发[/b]
耐弛膜材的生产商通常与国内外知名科研院校、膜结构公司等建立紧密的合作关系，进行技术交流、合作及成果交换。通过引进先进的生产设备和技术，不断提升产品的质量和性能。同时，生产商还注重产品的研发和创新，不断推出适应市场需求的新产品。
[b]五、总结[/b]
耐弛膜材作为一类高性能膜材的代表，以其优异的耐候性、耐久性、自洁性和化学稳定性等特点在多个领域得到广泛应用。随着技术的不断进步和市场的不断发展，耐弛膜材的产品种类和应用领域还将不断拓展和完善。然而，需要注意的是，由于“耐弛”并非一个明确的品牌名称，因此在实际应用中需要根据具体的产品信息和品牌标识进行选择。