//------------------------------------------------------------------------+
// Copyright (C), 1998-2011, Beijing Tangent Software Co. Ltd.
// = FileName	:   TConfigInfo.cpp
// = Version	:   ver1.0
// = Author		:   xlc
// = CreateDate	:   2011-10-14
// = Description:   结构随图数据接口函数声明
// = Maintainers: 
//                  
//------------------------------------------------------------------------+
#include "StdAfx.h"
#include "TConfigInfo.h"

//梁数据
//梁显示截面尺寸
BOOL TConfigInfo::DocGetBeamShowBH()
{
	BOOL bRet = FALSE;
	
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁显示截面尺寸"), bRet);
		p->close();
	}
	return bRet;
}
void TConfigInfo::DocSetBeamShowBH(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁显示截面尺寸"), bShow);
		p->close();
	}
}

//梁尺寸文字颜色
int TConfigInfo::DocGetBeamBHColor()
{
	int nRet = 7;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁尺寸文字颜色"), nRet);
		p->close();
	}
	return nRet;
}
void TConfigInfo::DocSetBeamBHColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁尺寸文字颜色"), nIndex);
		p->close();
	}
}
//梁尺寸文字样式
AcDbObjectId TConfigInfo::DocGetBeamBHStyle()
{
	AcDbSoftPointerId idRet = AcDbObjectId::kNull;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁尺寸文字样式"), idRet);
		p->close();
	}
	
	return idRet;
}
void TConfigInfo::DocSetBeamBHStyle(AcDbObjectId idObj)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁尺寸文字样式"), AcDbSoftPointerId(idObj));
		p->close();
	}
}
//梁尺寸文字字高
double TConfigInfo::DocGetBeamBHHigh()
{
	double dRet = 3.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁尺寸文字字高"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetBeamBHHigh(double dHeight)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁尺寸文字字高"), dHeight);
		p->close();
	}
}
//梁尺寸文字距离
double TConfigInfo::DocGetBeamBHDist()
{
	double dRet = 0.3;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁尺寸文字距离"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetBeamBHDist(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁尺寸文字距离"), dDist);
		p->close();
	}
}
//梁显示构件编号
BOOL TConfigInfo::DocGetBeamShowCL()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁显示构件编号"), bRet);
		p->close();
	}
	return bRet;
}
void TConfigInfo::DocSetBeamShowCL(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁显示构件编号"), bShow);
		p->close();
	}

}
//梁编号文字图层
CString TConfigInfo::DocGetBeamCLLayer()
{
	CString strLayer("0");

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁编号文字图层"), strLayer);
		p->close();
	}
	return strLayer;
}
void TConfigInfo::DocSetBeamCLLayer(const TCHAR * pszLayer)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁编号文字图层"), pszLayer);
		p->close();
	}

}

//梁编号文字颜色
int TConfigInfo::DocGetBeamCLColor()
{
	int nRet = 256;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁编号文字颜色"), nRet);
		p->close();
	}
	return nRet;
}

void TConfigInfo::DocSetBeamCLColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁编号文字颜色"), nIndex);
		p->close();
	}
}
//梁编号文字样式
AcDbObjectId TConfigInfo::DocGetBeamCLStyle()
{
	AcDbSoftPointerId idRet = AcDbObjectId::kNull;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁编号文字样式"), idRet);
		p->close();
	}
	return idRet;
}
void TConfigInfo::DocSetBeamCLStyle(AcDbObjectId idObj)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁编号文字样式"), AcDbSoftPointerId(idObj));
		p->close();
	}
}

//梁编号文字字高
double TConfigInfo::DocGetBeamCLHigh()
{
	double dRet = 3.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁编号文字字高"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetBeamCLHigh(double dHeight)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁编号文字字高"), dHeight);
		p->close();
	}
}

//梁编号文字距离
double TConfigInfo::DocGetBeamCLDist()
{
	double dRet = 0.3;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁编号文字距离"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetBeamCLDist(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁编号文字距离"), dDist);
		p->close();
	}
}

//梁显示单元文字
BOOL TConfigInfo::DocGetBeamShowNo()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁显示单元文字"), bRet);
		p->close();
	}
	return bRet;
}
void TConfigInfo::DocSetBeamShowNo(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁显示单元文字"), bShow);
		p->close();
	}
}

//梁单元文字颜色
int TConfigInfo::DocGetBeamNoColor()
{
	int nRet = 7;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁单元文字颜色"), nRet);
		p->close();
	}
	return nRet;
}
void TConfigInfo::DocSetBeamNoColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁单元文字颜色"), nIndex);
		p->close();
	}
}

//梁单元文字样式
AcDbObjectId TConfigInfo::DocGetBeamNoStyle()
{
	AcDbSoftPointerId idRet = AcDbObjectId::kNull;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁单元文字样式"), idRet);
		p->close();
	}
	return idRet;
}
void TConfigInfo::DocSetBeamNoStyle(AcDbObjectId idObj)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁单元文字样式"), AcDbSoftPointerId(idObj));
		p->close();
	}
}
//梁单元文字字高
double TConfigInfo::DocGetBeamNoHigh()
{
	double dRet = 3.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁单元文字字高"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetBeamNoHigh(double dHeight)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁单元文字字高"), dHeight);
		p->close();
	}

}
//梁单元文字距离
double TConfigInfo::DocGetBeamNoDist()
{
	double dRet = 0.3;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁单元文字距离"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetBeamNoDist(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁单元文字距离"), dDist);
		p->close();
	}
}
//梁显示刚域长度
BOOL TConfigInfo::DocGetBeamShowRG()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁显示刚域长度"), bRet);
		p->close();
	}
	return bRet;
}
void TConfigInfo::DocSetBeamShowRG(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁显示刚域长度"), bShow);
		p->close();
	}
}
//梁刚域长度文字颜色
int TConfigInfo::DocGetBeamRGColor()
{
	int nRet = 7;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁刚域长度文字颜色"), nRet);
		p->close();
	}
	return nRet;
}
void TConfigInfo::DocSetBeamRGColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁刚域长度文字颜色"), nIndex);
		p->close();
	}
}
//梁刚域长度文字样式
AcDbObjectId TConfigInfo::DocGetBeamRGStyle()
{
	AcDbSoftPointerId idRet = AcDbObjectId::kNull;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁刚域长度文字样式"), idRet);
		p->close();
	}
	return idRet;
}
void TConfigInfo::DocSetBeamRGStyle(AcDbObjectId idObj)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁刚域长度文字样式"), AcDbSoftPointerId(idObj));
		p->close();
	}
}
//梁刚域长度文字字高
double TConfigInfo::DocGetBeamRGHigh()
{
	double dRet = 3.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁刚域长度文字字高"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetBeamRGHigh(double dHeight)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁刚域长度文字字高"), dHeight);
		p->close();
	}
}
//梁刚域长度文字距离
double TConfigInfo::DocGetBeamRGDist()
{
	double dRet = 0.3;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁刚域长度文字距离"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetBeamRGDist(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁刚域长度文字距离"), dDist);
		p->close();
	}
}
//梁是否加粗
BOOL TConfigInfo::DocGetBeamIsLW()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁是否加粗"), bRet);
		p->close();
	}
	return bRet;
}
void TConfigInfo::DocSetBeamIsLW(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁是否加粗"), bShow);
		p->close();
	}
}
//梁加粗线宽
double TConfigInfo::DocGetBeamLWVal()
{
	double dRet = 0;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁加粗线宽"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetBeamLWVal(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁加粗线宽"), dDist);
		p->close();
	}
}
//梁平面表达形式
int TConfigInfo::DocGetBeamPMShow()
{
	int nRet = 2;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁平面表达形式"), nRet);
		p->close();
	}
	return nRet;
}
void TConfigInfo::DocSetBeamPMShow(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁平面表达形式"), nIndex);
		p->close();
	}
}
//梁三维表达形式
int TConfigInfo::DocGetBeam3DShow()
{
	int nRet = 2;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁三维面表达形式"), nRet);
		p->close();
	}
	return nRet;
}
void TConfigInfo::DocSetBeam3DShow(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁三维面表达形式"), nIndex);
		p->close();
	}
}
//梁融合控制
int TConfigInfo::DocGetBeamRelCtl()
{
	int nRet = 1;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁融合控制"), nRet);
		p->close();
	}
	return nRet;
}
void TConfigInfo::DocSetBeamRelCtl(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁融合控制"), nIndex);
		p->close();
	}
}
//梁虚实显示控制
int TConfigInfo::DocGetBeamLTCtl()
{
	int nRet = 1;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁虚实控制"), nRet);
		p->close();
	}
	return nRet;
}
void TConfigInfo::DocSetBeamLTCtl(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁虚实控制"), nIndex);
		p->close();
	}
}

//梁荷显示
BOOL TConfigInfo::DocGetBeamShowLoad()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S梁荷显示"), bRet);
		p->close();
	}
	return bRet;
}

void TConfigInfo::DocSetBeamShowLoad(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S梁荷显示"), bShow);
		p->close();
	}
}

//柱子数据
//柱子显示截面尺寸
BOOL TConfigInfo::DocGetColuShowBH()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子显示截面尺寸"), bRet);
		p->close();
	}
	return bRet;
}
void TConfigInfo::DocSetColuShowBH(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子显示截面尺寸"), bShow);
		p->close();
	}
}

//柱子尺寸文字颜色
int TConfigInfo::DocGetColuBHColor()
{
	int nRet = 7;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子尺寸文字颜色"), nRet);
		p->close();
	}
	return nRet;
}

void TConfigInfo::DocSetColuBHColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子尺寸文字颜色"), nIndex);
		p->close();
	}
}

//柱子尺寸文字样式
AcDbObjectId TConfigInfo::DocGetColuBHStyle()
{
	AcDbSoftPointerId idRet = AcDbObjectId::kNull;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子尺寸文字样式"), idRet);
		p->close();
	}
	return idRet;
}

void TConfigInfo::DocSetColuBHStyle(AcDbObjectId idObj)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子尺寸文字样式"), AcDbSoftPointerId(idObj));
		p->close();
	}
}

//柱子尺寸文字字高
double TConfigInfo::DocGetColuBHHigh()
{
	double dRet = 3.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子尺寸文字字高"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetColuBHHigh(double dHeight)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子尺寸文字字高"), dHeight);
		p->close();
	}
}

//柱子尺寸文字距离
double TConfigInfo::DocGetColuBHDist()
{
	double dRet = 0.3;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子尺寸文字距离"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetColuBHDist(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子尺寸文字距离"), dDist);
		p->close();
	}
}

//柱子显示构件编号
BOOL TConfigInfo::DocGetColuShowCL()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子显示构件编号"), bRet);
		p->close();
	}
	return bRet;
}

void TConfigInfo::DocSetColuShowCL(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子显示构件编号"), bShow);
		p->close();
	}
}

//柱子编号文字图层
CString TConfigInfo::DocGetColuCLLayer()
{
	CString strLayer("0");

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子编号文字图层"), strLayer);
		p->close();
	}
	return strLayer;
}

void TConfigInfo::DocSetColuCLLayer(const TCHAR * pszLayer)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子编号文字图层"), pszLayer);
		p->close();
	}
}

//柱子编号文字颜色
int TConfigInfo::DocGetColuCLColor()
{
	int nRet = 256;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子编号文字颜色"), nRet);
		p->close();
	}
	return nRet;
}

void TConfigInfo::DocSetColuCLColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子编号文字颜色"), nIndex);
		p->close();
	}
}

//柱子编号文字样式
AcDbObjectId TConfigInfo::DocGetColuCLStyle()
{
	AcDbSoftPointerId idRet = AcDbObjectId::kNull;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子编号文字样式"), idRet);
		p->close();
	}
	return idRet;
}

void TConfigInfo::DocSetColuCLStyle(AcDbObjectId idObj)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子编号文字样式"), AcDbSoftPointerId(idObj));
		p->close();
	}
}

//柱子编号文字字高
double TConfigInfo::DocGetColuCLHigh()
{
	double dRet = 3.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子编号文字字高"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetColuCLHigh(double dHeight)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子编号文字字高"), dHeight);
		p->close();
	}
}

//柱子编号文字距离
double TConfigInfo::DocGetColuCLDist()
{
	double dRet = 0.3;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子编号文字距离"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetColuCLDist(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子编号文字距离"), dDist);
		p->close();
	}
}

//柱子显示单元文字
BOOL TConfigInfo::DocGetColuShowNo()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子显示单元文字"), bRet);
		p->close();
	}
	return bRet;
}

void TConfigInfo::DocSetColuShowNo(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子显示单元文字"), bShow);
		p->close();
	}
}

//柱子单元文字颜色
int TConfigInfo::DocGetColuNoColor()
{
	int nRet = 7;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子单元文字颜色"), nRet);
		p->close();
	}
	return nRet;
}

void TConfigInfo::DocSetColuNoColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子单元文字颜色"), nIndex);
		p->close();
	}
}

//柱子单元文字样式
AcDbObjectId TConfigInfo::DocGetColuNoStyle()
{
	AcDbSoftPointerId idRet = AcDbObjectId::kNull;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子单元文字样式"), idRet);
		p->close();
	}
	return idRet;
}

void TConfigInfo::DocSetColuNoStyle(AcDbObjectId idObj)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子单元文字样式"), AcDbSoftPointerId(idObj));
		p->close();
	}
}

//柱子单元文字字高
double TConfigInfo::DocGetColuNoHigh()
{
	double dRet = 3.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子单元文字字高"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetColuNoHigh(double dHeight)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子单元文字字高"), dHeight);
		p->close();
	}
}

//柱子单元文字距离
double TConfigInfo::DocGetColuNoDist()
{
	double dRet = 0.3;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子单元文字距离"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetColuNoDist(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子单元文字距离"), dDist);
		p->close();
	}
}

//柱子显示刚域长度
BOOL TConfigInfo::DocGetColuShowRG()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子显示刚域长度"), bRet);
		p->close();
	}
	return bRet;
}

void TConfigInfo::DocSetColuShowRG(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子显示刚域长度"), bShow);
		p->close();
	}
}

//柱子刚域长度文字颜色
int TConfigInfo::DocGetColuRGColor()
{
	int nRet = 7;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子刚域长度文字颜色"), nRet);
		p->close();
	}
	return nRet;;
}

void TConfigInfo::DocSetColuRGColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子刚域长度文字颜色"), nIndex);
		p->close();
	}
}

//柱子刚域长度文字样式
AcDbObjectId TConfigInfo::DocGetColuRGStyle()
{
	AcDbSoftPointerId idRet = AcDbObjectId::kNull;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子刚域长度文字样式"), idRet);
		p->close();
	}
	return idRet;
}

void TConfigInfo::DocSetColuRGStyle(AcDbObjectId idObj)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子刚域长度文字样式"), AcDbSoftPointerId(idObj));
		p->close();
	}
}

//柱子刚域长度文字字高
double TConfigInfo::DocGetColuRGHigh()
{
	double dRet = 3.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子刚域长度文字字高"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetColuRGHigh(double dHeight)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子刚域长度文字字高"), dHeight);
		p->close();
	}
}

//柱子刚域长度文字距离
double TConfigInfo::DocGetColuRGDist()
{
	double dRet = 0.3;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子刚域长度文字距离"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetColuRGDist(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子刚域长度文字距离"), dDist);
		p->close();
	}
}

//柱子填充样式
CString TConfigInfo::DocGetColuHPatte()
{
	CString strLayer("Solid");

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子填充样式"), strLayer);
		p->close();
	}
	return strLayer;
}

void TConfigInfo::DocSetColuHPatte(const TCHAR * pszPatte)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子填充样式"), pszPatte);
		p->close();
	}
}

//柱子是否加粗
BOOL TConfigInfo::DocGetColuIsLW()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子是否加粗"), bRet);
		p->close();
	}
	return bRet;
}

void TConfigInfo::DocSetColuIsLW(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子是否加粗"), bShow);
		p->close();
	}
}

//柱子加粗线宽
double TConfigInfo::DocGetColuLWVal()
{
	double dRet = 0;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子加粗线宽"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetColuLWVal(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子加粗线宽"), dDist);
		p->close();
	}
}

//柱子三维表达形式
int TConfigInfo::DocGetColu3DShow()
{
	int nRet = 2;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱子三维表达形式"), nRet);
		p->close();
	}
	return nRet;
}

void TConfigInfo::DocSetColu3DShow(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱子三维表达形式"), nIndex);
		p->close();
	}
}

//柱荷显示
BOOL TConfigInfo::DocGetColuShowLoad()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S柱荷显示"), bRet);
		p->close();
	}
	return bRet;
}

void TConfigInfo::DocSetColuShowLoad(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S柱荷显示"), bShow);
		p->close();
	}
}

//剪力墙数据
//剪力墙显示墙宽
BOOL TConfigInfo::DocGetWallShowBH()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙显示墙宽"), bRet);
		p->close();
	}
	return bRet;
}

void TConfigInfo::DocSetWallShowBH(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙显示墙宽"), bShow);
		p->close();
	}
}

//剪力墙尺寸文字颜色
int TConfigInfo::DocGetWallBHColor()
{
	int nRet = 7;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙尺寸文字颜色"), nRet);
		p->close();
	}
	return nRet;
}

void TConfigInfo::DocSetWallBHColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙尺寸文字颜色"), nIndex);
		p->close();
	}
}

//剪力墙尺寸文字样式
AcDbObjectId TConfigInfo::DocGetWallBHStyle()
{
	AcDbSoftPointerId idRet = AcDbObjectId::kNull;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙尺寸文字样式"), idRet);
		p->close();
	}
	return idRet;
}

void TConfigInfo::DocSetWallBHStyle(AcDbObjectId idObj)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙尺寸文字样式"), AcDbSoftPointerId(idObj));
		p->close();
	}
}

//剪力墙尺寸文字字高
double TConfigInfo::DocGetWallBHHigh()
{
	double dRet = 3.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙尺寸文字字高"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetWallBHHigh(double dHeight)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙尺寸文字字高"), dHeight);
		p->close();
	}
}

//剪力墙尺寸文字距离
double TConfigInfo::DocGetWallBHDist()
{
	double dRet = 0.3;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙尺寸文字距离"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetWallBHDist(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙尺寸文字距离"), dDist);
		p->close();
	}
}

//剪力墙显示构件编号
BOOL TConfigInfo::DocGetWallShowCL()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙显示构件编号"), bRet);
		p->close();
	}
	return bRet;
}

void TConfigInfo::DocSetWallShowCL(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙显示构件编号"), bShow);
		p->close();
	}
}

//剪力墙编号文字图层
CString TConfigInfo::DocGetWallCLLayer()
{
	CString strLayer("0");

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙编号文字图层"), strLayer);
		p->close();
	}
	return strLayer;
}

void TConfigInfo::DocSetWallCLLayer(const TCHAR * pszLayer)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙编号文字图层"), pszLayer);
		p->close();
	}
}

//剪力墙编号文字颜色
int TConfigInfo::DocGetWallCLColor()
{
	int nRet = 256;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙编号文字颜色"), nRet);
		p->close();
	}
	return nRet;
}

void TConfigInfo::DocSetWallCLColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙编号文字颜色"), nIndex);
		p->close();
	}
}

//剪力墙编号文字样式
AcDbObjectId TConfigInfo::DocGetWallCLStyle()
{
	AcDbSoftPointerId idRet = AcDbObjectId::kNull;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙编号文字样式"), idRet);
		p->close();
	}
	return idRet;
}

void TConfigInfo::DocSetWallCLStyle(AcDbObjectId idObj)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙编号文字样式"), AcDbSoftPointerId(idObj));
		p->close();
	}
}

//剪力墙编号文字字高
double TConfigInfo::DocGetWallCLHigh()
{
	double dRet = 3.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙编号文字字高"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetWallCLHigh(double dHeight)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙编号文字字高"), dHeight);
		p->close();
	}
}

//剪力墙编号文字距离
double TConfigInfo::DocGetWallCLDist()
{
	double dRet = 0.3;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙编号文字距离"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetWallCLDist(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙编号文字距离"), dDist);
		p->close();
	}
}

//剪力墙填充样式
CString TConfigInfo::DocGetWallHPatte()
{
	CString strLayer("Solid");

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙填充样式"), strLayer);
		p->close();
	}
	return strLayer;
}

void TConfigInfo::DocSetWallHPatte(const TCHAR * pszPatte)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙填充样式"), pszPatte);
		p->close();
	}
}

//剪力墙是否加粗
BOOL TConfigInfo::DocGetWallIsLW()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙是否加粗"), bRet);
		p->close();
	}
	return bRet;
}

void TConfigInfo::DocSetWallIsLW(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙是否加粗"), bShow);
		p->close();
	}
}

//剪力墙加粗线宽
double TConfigInfo::DocGetWallLWVal()
{
	double dRet = 0;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙加粗线宽"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetWallLWVal(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙加粗线宽"), dDist);
		p->close();
	}

}

//剪力墙虚实显示控制
int TConfigInfo::DocGetWallLTCtl()
{
	int nRet = 1;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙虚实控制"), nRet);
		p->close();
	}
	return nRet;
}

void TConfigInfo::DocSetWallLTCtl(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙虚实控制"), nIndex);
		p->close();
	}
}

//墙荷显示
BOOL TConfigInfo::DocGetWallShowLoad()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S墙荷显示"), bRet);
		p->close();
	}
	return bRet;
}

void TConfigInfo::DocSetWallShowLoad(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S墙荷显示"), bShow);
		p->close();
	}
}

//墙洞数据
//墙洞显示洞口尺寸
BOOL TConfigInfo::DocGetWallHoleShowBH()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S墙洞显示洞口尺寸"), bRet);
		p->close();
	}
	return bRet;
}

void TConfigInfo::DocSetWallHoleShowBH(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S墙洞显示洞口尺寸"), bShow);
		p->close();
	}

}

//墙洞尺寸文字颜色
int TConfigInfo::DocGetWallHoleBHColor()
{
	int nRet = 7;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S墙洞尺寸文字颜色"), nRet);
		p->close();
	}
	return nRet;
}

void TConfigInfo::DocSetWallHoleBHColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S墙洞尺寸文字颜色"), nIndex);
		p->close();
	}
}

//墙洞尺寸文字样式
AcDbObjectId TConfigInfo::DocGetWallHoleBHStyle()
{
	AcDbSoftPointerId idRet = AcDbObjectId::kNull;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S墙洞尺寸文字样式"), idRet);
		p->close();
	}
	return idRet;
}

void TConfigInfo::DocSetWallHoleBHStyle(AcDbObjectId idObj)
{

	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S墙洞尺寸文字样式"), AcDbSoftPointerId(idObj));
		p->close();
	}
}

//墙洞尺寸文字字高
double TConfigInfo::DocGetWallHoleBHHigh()
{
	double dRet = 3.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S墙洞尺寸文字字高"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetWallHoleBHHigh(double dHeight)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S墙洞尺寸文字字高"), dHeight);
		p->close();
	}
}

//墙洞尺寸文字距离
double TConfigInfo::DocGetWallHoleBHDist()
{
	double dRet = 0.3;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S墙洞尺寸文字距离"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetWallHoleBHDist(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S墙洞尺寸文字距离"), dDist);
		p->close();
	}
}


//板洞数据
//板洞显示洞口尺寸
BOOL TConfigInfo::DocGetSlabHoleShowBH()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S板洞显示洞口尺寸"), bRet);
		p->close();
	}
	return bRet;
}

void TConfigInfo::DocSetSlabHoleShowBH(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S板洞显示洞口尺寸"), bShow);
		p->close();
	}
}

//板洞尺寸文字颜色
int TConfigInfo::DocGetSlabHoleBHColor()
{
	int nRet = 7;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S板洞尺寸文字颜色"), nRet);
		p->close();
	}
	return nRet;
}

void TConfigInfo::DocSetSlabHoleBHColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S板洞尺寸文字颜色"), nIndex);
		p->close();
	}
}

//板洞尺寸文字样式
AcDbObjectId TConfigInfo::DocGetSlabHoleBHStyle()
{
	AcDbSoftPointerId idRet = AcDbObjectId::kNull;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S板洞尺寸文字样式"), idRet);
		p->close();
	}
	return idRet;
}

void TConfigInfo::DocSetSlabHoleBHStyle(AcDbObjectId idObj)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S板洞尺寸文字样式"), AcDbSoftPointerId(idObj));
		p->close();
	}
}

//板洞尺寸文字字高
double TConfigInfo::DocGetSlabHoleBHHigh()
{
	double dRet = 3.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S板洞尺寸文字字高"), dRet);
		p->close();
	}
	return dRet;;
}

void TConfigInfo::DocSetSlabHoleBHHigh(double dHeight)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S板洞尺寸文字字高"), dHeight);
		p->close();
	}
}

//板洞尺寸文字距离
double TConfigInfo::DocGetSlabHoleBHDist()
{
	double dRet = 0.3;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S板洞尺寸文字距离"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetSlabHoleBHDist(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S板洞尺寸文字距离"), dDist);
		p->close();
	}
}

//板洞显示折线
BOOL TConfigInfo::DocGetSlabHoleShowZX()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S板洞显示折线"), bRet);
		p->close();
	}
	return bRet;
}

void TConfigInfo::DocSetSlabHoleShowZX(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S板洞显示折线"), bShow);
		p->close();
	}
}

//板洞是否填充
BOOL TConfigInfo::DocGetSlabHoleHatch()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S板洞是否填充"), bRet);
		p->close();
	}
	return bRet;
}

void TConfigInfo::DocSetSlabHoleHatch(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S板洞是否填充"), bShow);
		p->close();
	}
}

//板洞填充样式
CString TConfigInfo::DocGetSlabHoleHPatte()
{
	CString strLayer("Solid");

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S板洞填充样式"), strLayer);
		p->close();
	}
	return strLayer;
}

void TConfigInfo::DocSetSlabHoleHPatte(const TCHAR * pszPatte)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S板洞填充样式"), pszPatte);
		p->close();
	}
}


//楼板数据
//楼板显示板厚
BOOL TConfigInfo::DocGetSlabShowBH()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S楼板显示板厚"), bRet);
		p->close();
	}
	return bRet;
}

void TConfigInfo::DocSetSlabShowBH(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S楼板显示板厚"), bShow);
		p->close();
	}
}

//楼板尺寸文字颜色
int TConfigInfo::DocGetSlabBHColor()
{
	int nRet = 7;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S楼板尺寸文字颜色"), nRet);
		p->close();
	}
	return nRet;
}

void TConfigInfo::DocSetSlabBHColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S楼板尺寸文字颜色"), nIndex);
		p->close();
	}
}

//楼板尺寸文字样式
AcDbObjectId TConfigInfo::DocGetSlabBHStyle()
{
	AcDbSoftPointerId idRet = AcDbObjectId::kNull;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S楼板尺寸文字样式"), idRet);
		p->close();
	}
	return idRet;
}

void TConfigInfo::DocSetSlabBHStyle(AcDbObjectId idObj)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S楼板尺寸文字样式"), AcDbSoftPointerId(idObj));
		p->close();
	}
}

//楼板尺寸文字字高
double TConfigInfo::DocGetSlabBHHigh()
{
	double dRet = 3.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S楼板尺寸文字字高"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetSlabBHHigh(double dHeight)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S楼板尺寸文字字高"), dHeight);
		p->close();
	}
}

//楼板尺寸文字距离
double TConfigInfo::DocGetSlabBHDist()
{
	double dRet = 0.3;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S楼板尺寸文字距离"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetSlabBHDist(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S楼板尺寸文字距离"), dDist);
		p->close();
	}
}

//楼板显示构件编号
BOOL TConfigInfo::DocGetSlabShowCL()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S楼板显示构件编号"), bRet);
		p->close();
	}
	return bRet;
}

void TConfigInfo::DocSetSlabShowCL(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S楼板显示构件编号"), bShow);
		p->close();
	}
}

//楼板编号文字图层
CString TConfigInfo::DocGetSlabCLLayer()
{
	CString strLayer("0");

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S楼板编号文字图层"), strLayer);
		p->close();
	}
	return strLayer;
}

void TConfigInfo::DocSetSlabCLLayer(const TCHAR * pszLayer)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S楼板编号文字图层"), pszLayer);
		p->close();
	}
}

//楼板编号文字颜色
int TConfigInfo::DocGetSlabCLColor()
{
	int nRet = 256;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S楼板编号文字颜色"), nRet);
		p->close();
	}
	return nRet;
}

void TConfigInfo::DocSetSlabCLColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S楼板编号文字颜色"), nIndex);
		p->close();
	}
}

//楼板编号文字样式
AcDbObjectId TConfigInfo::DocGetSlabCLStyle()
{
	AcDbSoftPointerId idRet = AcDbObjectId::kNull;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S楼板编号文字样式"), idRet);
		p->close();
	}
	return idRet;
}

void TConfigInfo::DocSetSlabCLStyle(AcDbObjectId idObj)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S楼板编号文字样式"), AcDbSoftPointerId(idObj));
		p->close();
	}
}

//楼板编号文字字高
double TConfigInfo::DocGetSlabCLHigh()
{
	double dRet = 3.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S楼板编号文字字高"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetSlabCLHigh(double dHeight)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S楼板编号文字字高"), dHeight);
		p->close();
	}
}

//楼板编号文字距离
double TConfigInfo::DocGetSlabCLDist()
{
	double dRet = 0.3;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S楼板编号文字距离"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetSlabCLDist(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S楼板编号文字距离"), dDist);
		p->close();
	}
}

//楼板显示导荷
BOOL TConfigInfo::DocGetSlabShowDH()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S楼板显示导荷"), bRet);
		p->close();
	}
	return bRet;
}

void TConfigInfo::DocSetSlabShowDH(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S楼板显示导荷"), bShow);
		p->close();
	}
}

//楼板导荷图层
CString TConfigInfo::DocGetSlabDHLayer()
{
	CString strLayer("0");

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S楼板导荷图层"), strLayer);
		p->close();
	}
	return strLayer;
}

void TConfigInfo::DocSetSlabDHLayer(const TCHAR * pszLayer)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S楼板导荷图层"), pszLayer);
		p->close();
	}
}

//楼板导荷颜色
int TConfigInfo::DocGetSlabDHColor()
{
	int nRet = 256;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S楼板导荷颜色"), nRet);
		p->close();
	}
	return nRet;
}

void TConfigInfo::DocSetSlabDHColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S楼板导荷颜色"), nIndex);
		p->close();
	}
}
//面荷显示
BOOL TConfigInfo::DocGetSlabShowLoad()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S面荷显示"), bRet);
		p->close();
	}
	return bRet;
}
void TConfigInfo::DocSetSlabShowLoad(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S面荷显示"), bShow);
		p->close();
	}
}

//节点数据
//节点显示编号
BOOL TConfigInfo::DocGetNodeShowNo()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S节点显示编号"), bRet);
		p->close();
	}
	return bRet;
}

void TConfigInfo::DocSetNodeShowNo(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S节点显示编号"), bShow);
		p->close();
	}
}

//节点编号文字颜色
int TConfigInfo::DocGetNodeNoColor()
{
	int nRet = 7;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S节点编号文字颜色"), nRet);
		p->close();
	}
	return nRet;
}

void TConfigInfo::DocSetNodeNoColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S节点编号文字颜色"), nIndex);
		p->close();
	}
}

//节点编号文字样式
AcDbObjectId TConfigInfo::DocGetNodeNoStyle()
{
	AcDbSoftPointerId idRet = AcDbObjectId::kNull;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S节点编号文字样式"), idRet);
		p->close();
	}
	return idRet;
}

void TConfigInfo::DocSetNodeNoStyle(AcDbObjectId idObj)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S节点编号文字样式"), AcDbSoftPointerId(idObj));
		p->close();
	}
}

//节点编号文字字高
double TConfigInfo::DocGetNodeNoHigh()
{
	double dRet = 3.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S节点编号文字字高"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetNodeNoHigh(double dHeight)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S节点编号文字字高"), dHeight);
		p->close();
	}
}

//节点编号文字距离
double TConfigInfo::DocGetNodeNoDist()
{
	double dRet = 0.3;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S节点编号文字距离"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetNodeNoDist(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S节点编号文字距离"), dDist);
		p->close();
	}
}

//节点圆点直径
double TConfigInfo::DocGetNodePtSize()
{
	double dRet = 0.8;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S节点圆点直径"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetNodePtSize(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S节点圆点直径"), dDist);
		p->close();
	}
}

//节点显示节点
BOOL TConfigInfo::DocGetNodeShowPt()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S节点显示节点"), bRet);
		p->close();
	}
	return bRet;
}

void TConfigInfo::DocSetNodeShowPt(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S节点显示节点"), bShow);
		p->close();
	}
}

//节点圆点颜色
int TConfigInfo::DocGetNodePtColor()
{
	int nRet = 7;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S节点圆点颜色"), nRet);
		p->close();
	}
	return nRet;
}

void TConfigInfo::DocSetNodePtColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S节点圆点颜色"), nIndex);
		p->close();
	}
}

//节点荷载显示
BOOL TConfigInfo::DocGetNodeShowLoad()
{
	BOOL bRet = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S节点显示"), bRet);
		p->close();
	}
	return bRet;
}
void TConfigInfo::DocSetNodeShowLoad(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S节点显示"), bShow);
		p->close();
	}
}

//荷载字高
double TConfigInfo::DocGetLoadTextHeight()
{
	double dRet = 300;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S荷载字高"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetTextHeight(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S荷载字高"), dDist);
		p->close();
	}
}

//荷载字宽
double TConfigInfo::DocGetLoadTextWidth()
{
	double dRet = 300;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S荷载字宽"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetTextWidth(double dDist)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S荷载字宽"), dDist);
		p->close();
	}
}

//显示荷载参数
BOOL TConfigInfo::DocGetShowLoadPara()
{
	BOOL bRet = TRUE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S显示荷载参数"), bRet);
		p->close();
	}
	return bRet;
}
void TConfigInfo::DocSetShowLoadPara(BOOL bShow)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S显示荷载参数"), bShow);
		p->close();
	}
}

//截面尺寸文字字高
double TConfigInfo::DocGetBHHigh()
{
	double dRet = 3.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S截面尺寸文字字高"), dRet);
		p->close();
	}
	return dRet;
}

void TConfigInfo::DocSetBHHigh(double dHeight)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S截面尺寸文字字高"), dHeight);
		p->close();
	}
}

//单元编号文字字高
double TConfigInfo::DocGetNoHigh()
{
	double dRet = 3.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S单元编号文字字高"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetNoHigh(double dHeight)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S单元编号文字字高"), dHeight);
		p->close();
	}

}

//刚域长度文字字高
double TConfigInfo::DocGetRGHigh()
{
	double dRet = 3.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S刚域长度文字字高"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetRGHigh(double dHeight)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S刚域长度文字字高"), dHeight);
		p->close();
	}
}

//混凝土柱子填充样式
CString TConfigInfo::DocGetConColuHPatte()
{
	CString strLayer("Solid");

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S混凝土柱子填充样式"), strLayer);
		p->close();
	}
	return strLayer;
}
void TConfigInfo::DocSetConColuHPatte(const TCHAR * pszPatte)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S混凝土柱子填充样式"), pszPatte);
		p->close();
	}
}
//混凝土柱子填充颜色
int TConfigInfo::DocGetConColuHColor()
{
	int nRet = 256;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S混凝土柱子填充颜色"), nRet);
		p->close();
	}
	return nRet;
}
void TConfigInfo::DocSetConColuHColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S混凝土柱子填充颜色"), nIndex);
		p->close();
	}
}
//混凝土柱子标准线宽
double TConfigInfo::DocGetConColuSWeight()
{
	double dRet = 0.4;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S混凝土柱子标准线宽"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetConColuSWeight(double dVal)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S混凝土柱子标准线宽"), dVal);
		p->close();
	}
}
//混凝土柱子加粗线宽
double TConfigInfo::DocGetConColuLWeight()
{
	double dRet = 0.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S混凝土柱子加粗线宽"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetConColuLWeight(double dVal)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S混凝土柱子加粗线宽"), dVal);
		p->close();
	}
}

//钢柱填充样式
CString TConfigInfo::DocGetStlColuHPatte()
{
	CString strLayer("Solid");

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S钢柱填充样式"), strLayer);
		p->close();
	}
	return strLayer;
}
void TConfigInfo::DocSetStlColuHPatte(const TCHAR * pszPatte)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S钢柱填充样式"), pszPatte);
		p->close();
	}
}
//钢柱填充颜色
int TConfigInfo::DocGetStlColuHColor()
{
	int nRet = 256;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S钢柱填充颜色"), nRet);
		p->close();
	}
	return nRet;
}
void TConfigInfo::DocSetStlColuHColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S钢柱填充颜色"), nIndex);
		p->close();
	}
}
//钢柱标准线宽
double TConfigInfo::DocGetStlColuSWeight()
{
	double dRet = 0.4;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S钢柱标准线宽"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetStlColuSWeight(double dVal)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S钢柱标准线宽"), dVal);
		p->close();
	}
}
//钢柱加粗线宽
double TConfigInfo::DocGetStlColuLWeight()
{
	double dRet = 0.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S钢柱加粗线宽"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetStlColuLWeight(double dVal)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S钢柱加粗线宽"), dVal);
		p->close();
	}
}

//剪力墙填充样式
CString TConfigInfo::DocGetConWallHPatte()
{
	CString strLayer("Solid");

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙填充样式"), strLayer);
		p->close();
	}
	return strLayer;
}
void TConfigInfo::DocSetConWallHPatte(const TCHAR * pszPatte)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙填充样式"), pszPatte);
		p->close();
	}
}
//剪力墙填充颜色
int TConfigInfo::DocGetConWallHColor()
{
	int nRet = 256;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙填充颜色"), nRet);
		p->close();
	}
	return nRet;
}
void TConfigInfo::DocSetConWallHColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙填充颜色"), nIndex);
		p->close();
	}
}
//剪力墙标准线宽
double TConfigInfo::DocGetConWallSWeight()
{
	double dRet = 0.4;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙标准线宽"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetConWallSWeight(double dVal)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙标准线宽"), dVal);
		p->close();
	}
}
//剪力墙加粗线宽
double TConfigInfo::DocGetConWallLWeight()
{
	double dRet = 0.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙加粗线宽"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetConWallLWeight(double dVal)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙加粗线宽"), dVal);
		p->close();
	}
}

//混凝土梁填充样式
CString TConfigInfo::DocGetConBeamHPatte()
{
	CString strLayer("Solid");

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S混凝土梁填充样式"), strLayer);
		p->close();
	}
	return strLayer;
}
void TConfigInfo::DocSetConBeamHPatte(const TCHAR * pszPatte)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S混凝土梁填充样式"), pszPatte);
		p->close();
	}
}
//混凝土梁填充颜色
int TConfigInfo::DocGetConBeamHColor()
{
	int nRet = 256;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S混凝土梁填充颜色"), nRet);
		p->close();
	}
	return nRet;
}
void TConfigInfo::DocSetConBeamHColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S混凝土梁填充颜色"), nIndex);
		p->close();
	}
}
//混凝土梁标准线宽
double TConfigInfo::DocGetConBeamSWeight()
{
	double dRet = 0.4;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S混凝土梁标准线宽"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetConBeamSWeight(double dVal)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S混凝土梁标准线宽"), dVal);
		p->close();
	}
}
//混凝土梁加粗线宽
double TConfigInfo::DocGetConBeamLWeight()
{
	double dRet = 0.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S混凝土梁加粗线宽"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetConBeamLWeight(double dVal)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S混凝土梁加粗线宽"), dVal);
		p->close();
	}
}

//钢梁填充样式
CString TConfigInfo::DocGetStlBeamHPatte()
{
	CString strLayer("Solid");

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S钢梁填充样式"), strLayer);
		p->close();
	}
	return strLayer;
}
void TConfigInfo::DocSetStlBeamHPatte(const TCHAR * pszPatte)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S钢梁填充样式"), pszPatte);
		p->close();
	}
}
//钢梁填充颜色
int TConfigInfo::DocGetStlBeamHColor()
{
	int nRet = 256;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S钢梁填充颜色"), nRet);
		p->close();
	}
	return nRet;
}
void TConfigInfo::DocSetStlBeamHColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S钢梁填充颜色"), nIndex);
		p->close();
	}
}
//钢梁标准线宽
double TConfigInfo::DocGetStlBeamSWeight()
{
	double dRet = 0.4;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S钢梁标准线宽"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetStlBeamSWeight(double dVal)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S钢梁标准线宽"), dVal);
		p->close();
	}
}
//钢梁加粗线宽
double TConfigInfo::DocGetStlBeamLWeight()
{
	double dRet = 0.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S钢梁加粗线宽"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetStlBeamLWeight(double dVal)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S钢梁加粗线宽"), dVal);
		p->close();
	}
}

//楼板填充样式
CString TConfigInfo::DocGetConSlabHPatte()
{
	CString strLayer("Solid");

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S楼板填充样式"), strLayer);
		p->close();
	}
	return strLayer;
}
void TConfigInfo::DocSetConSlabHPatte(const TCHAR * pszPatte)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S楼板填充样式"), pszPatte);
		p->close();
	}
}
//楼板填充颜色
int TConfigInfo::DocGetConSlabHColor()
{
	int nRet = 256;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S楼板填充颜色"), nRet);
		p->close();
	}
	return nRet;
}
void TConfigInfo::DocSetConSlabHColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S楼板填充颜色"), nIndex);
		p->close();
	}
}
//楼板标准线宽
double TConfigInfo::DocGetConSlabSWeight()
{
	double dRet = 0.4;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S楼板标准线宽"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetConSlabSWeight(double dVal)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S楼板标准线宽"), dVal);
		p->close();
	}
}
//楼板加粗线宽
double TConfigInfo::DocGetConSlabLWeight()
{
	double dRet = 0.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S楼板加粗线宽"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetConSlabLWeight(double dVal)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S楼板加粗线宽"), dVal);
		p->close();
	}
}

//板洞填充样式
CString TConfigInfo::DocGetConHoleHPatte()
{
	CString strLayer("Solid");

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S板洞填充样式"), strLayer);
		p->close();
	}
	return strLayer;
}
void TConfigInfo::DocSetConHoleHPatte(const TCHAR * pszPatte)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S板洞填充样式"), pszPatte);
		p->close();
	}
}
//板洞填充颜色
int TConfigInfo::DocGetConHoleHColor()
{
	int nRet = 256;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S板洞填充颜色"), nRet);
		p->close();
	}
	return nRet;
}
void TConfigInfo::DocSetConHoleHColor(int nIndex)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S板洞填充颜色"), nIndex);
		p->close();
	}
}
//板洞标准线宽
double TConfigInfo::DocGetConHoleSWeight()
{
	double dRet = 0.4;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S板洞标准线宽"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetConHoleSWeight(double dVal)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S板洞标准线宽"), dVal);
		p->close();
	}
}
//板洞加粗线宽
double TConfigInfo::DocGetConHoleLWeight()
{
	double dRet = 0.5;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S板洞加粗线宽"), dRet);
		p->close();
	}
	return dRet;
}
void TConfigInfo::DocSetConHoleLWeight(double dVal)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S板洞加粗线宽"), dVal);
		p->close();
	}
}

// 混凝土柱是否加粗
BOOL TConfigInfo::DocGetConColuThick()
{
	BOOL bThick = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S混凝土柱是否加粗"), bThick);
		p->close();
	}
	return bThick;
}

void TConfigInfo::DocSetConColuThick(BOOL bThick)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S混凝土柱是否加粗"), bThick);
		p->close();
	}
}


// 钢柱是否加粗
BOOL TConfigInfo::DocGetStlColuThick()
{
	BOOL bThick = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S钢柱是否加粗"), bThick);
		p->close();
	}
	return bThick;
}

void TConfigInfo::DocSetStlColuThick(BOOL bThick)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S钢柱是否加粗"), bThick);
		p->close();
	}
}


// 混凝土梁是否加粗
BOOL TConfigInfo::DocGetConBeamThick()
{
	BOOL bThick = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S混凝土梁是否加粗"), bThick);
		p->close();
	}
	return bThick;
}

void TConfigInfo::DocSetConBeamThick(BOOL bThick)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S混凝土梁是否加粗"), bThick);
		p->close();
	}
}

// 钢梁是否加粗
BOOL TConfigInfo::DocGetStlBeamThick()
{
	BOOL bThick = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S钢梁是否加粗"), bThick);
		p->close();
	}
	return bThick;
}

void TConfigInfo::DocSetStlBeamThick(BOOL bThick)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S钢梁是否加粗"), bThick);
		p->close();
	}
}


// 剪力墙是否加粗
BOOL TConfigInfo::DocGetWallThick()
{
	BOOL bThick = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙是否加粗"), bThick);
		p->close();
	}
	return bThick;
}

void TConfigInfo::DocSetWallThick(BOOL bThick)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙是否加粗"), bThick);
		p->close();
	}
}


// 楼板加粗
BOOL TConfigInfo::DocGetConSlabThick()
{
	BOOL bThick = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S楼板是否加粗"), bThick);
		p->close();
	}
	return bThick;
}

void TConfigInfo::DocSetConSlabThick(BOOL bThick)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S楼板是否加粗"), bThick);
		p->close();
	}
}

// 板洞是否加粗
BOOL TConfigInfo::DocGetSlabHoleThick()
{
	BOOL bThick = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S板洞是否加粗"), bThick);
		p->close();
	}
	return bThick;
}

void TConfigInfo::DocSetSlabHoleThick(BOOL bThick)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S板洞是否加粗"), bThick);
		p->close();
	}
}

// 显示状态设置中的填充设置
// 混凝土柱是否填充
BOOL TConfigInfo::DocGetConColuHatch()
{
	BOOL bHatch = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead, g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S混凝土柱是否填充"), bHatch);
		p->close();
	}
	return bHatch;
}

void TConfigInfo::DocSetConColuHatch(BOOL bHatch)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite, g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S混凝土柱是否填充"), bHatch);
		p->close();
	}
}

// 钢柱是否填充
BOOL TConfigInfo::DocGetStlColuHatch()
{
	BOOL bHatch = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S钢柱是否填充"), bHatch);
		p->close();
	}
	return bHatch;
}

void TConfigInfo::DocSetStlColuHatch(BOOL bHatch)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S钢柱是否填充"), bHatch);
		p->close();
	}
}

// 混凝土梁是否填充
BOOL TConfigInfo::DocGetConBeamHatch()
{
	BOOL bHatch = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S混凝土梁是否填充"), bHatch);
		p->close();
	}
	return bHatch;
}

void TConfigInfo::DocSetConBeamHatch(BOOL bHatch)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S混凝土梁是否填充"), bHatch);
		p->close();
	}
}

// 钢梁是否填充
BOOL TConfigInfo::DocGetStlBeamHatch()
{
	BOOL bHatch = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S钢梁是否填充"), bHatch);
		p->close();
	}
	return bHatch;
}

void TConfigInfo::DocSetStlBeamHatch(BOOL bHatch)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S钢梁是否填充"), bHatch);
		p->close();
	}
}

// 剪力墙是否填充
BOOL TConfigInfo::DocGetWallHatch()
{
	BOOL bHatch = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S剪力墙是否填充"), bHatch);
		p->close();
	}
	return bHatch;
}

void TConfigInfo::DocSetWallHatch(BOOL bHatch)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S剪力墙是否填充"), bHatch);
		p->close();
	}
}

//楼板是否填充
BOOL TConfigInfo::DocGetConSlabHatch()
{
	BOOL bHatch = FALSE;

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->GetFields().GFD(_T("S楼板是否填充"), bHatch);
		p->close();
	}
	return bHatch;
}

void TConfigInfo::DocSetConSlabHatch(BOOL bHatch)
{
	TDocLock vLock;
	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S楼板是否填充"), bHatch);
		p->close();
	}
}

//显示单元编号
BOOL TConfigInfo::DocGetShowNo()
{
	BOOL bShow = FALSE;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->Fields().GFD(_T("S是否显示单元编号"),bShow);
		p->close();
	}
	return bShow;
}

void TConfigInfo::DocSetShowNo(BOOL bTrue)
{
	TDocLock vLock;

	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S是否显示单元编号"),bTrue);		
		p->close();
	}
}


//显示截面尺寸
BOOL TConfigInfo::DocGetShowBH()
{
	BOOL bShow = FALSE;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->Fields().GFD(_T("S是否显示截面尺寸"),bShow);
		p->close();
	}
	return bShow;
}

void TConfigInfo::DocSetShowBH(BOOL bTrue)
{
	TDocLock vLock;

	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S是否显示截面尺寸"),bTrue);		
		p->close();
	}
}

//显示刚域长度
BOOL TConfigInfo::DocGetShowRG()
{
	BOOL bShow = FALSE;
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	if(p)
	{
		p->Fields().GFD(_T("S是否显示刚域长度"),bShow);
		p->close();
	}
	return bShow;
}

void TConfigInfo::DocSetShowRG(BOOL bTrue)
{
	TDocLock vLock;

	TDbConfig *p = GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(p)
	{
		p->Fields().SFD(_T("S是否显示刚域长度"),bTrue);		
		p->close();
	}
}