// SanitaryDefineDlg.cpp : implementation file
//

#include "stdafx.h"
#include "SanitaryDefineDlg.h"
#include "SelectBlkDlg.h"
#include "SanitaryDangDlg.h"
#include "SanitaryTypeDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


void ChangeBlkColor(PickSet &ss, int iCol)
{
    long len = ss.Length();
    for(long i=0;i<len;i++){
        Entity entBlk = ss[i];
        TCHAR szBlkName[256];
        entBlk.GetData(2, szBlkName);
        AcDbBlockTableRecord *pRecord = NULL; 
        AcDbBlockTable* pBlockTable = NULL;
        acdbCurDwg()->getBlockTable(pBlockTable, AcDb::kForRead);
        if(!pBlockTable)
            return;
        if(Acad::eOk != pBlockTable->getAt(szBlkName, pRecord, AcDb::kForRead)){
            pBlockTable->close();
            return;
        }
        pBlockTable->close();
        if(!pRecord)
            return;
        
        AcDbBlockTableRecordIterator *pIterator = NULL;
        pRecord->newIterator(pIterator);
        pRecord->close();
        if(!pIterator)
            return;
        for(pIterator->start(); !pIterator->done(); pIterator->step()){
            AcDbEntity *pEnt = NULL;
            pIterator->getEntity(pEnt, AcDb::kForWrite);
            if(pEnt){
                pEnt->setLayer(_T("0"));
                pEnt->setColorIndex(iCol);
                pEnt->close();
            }
        }
        delete pIterator;
        entBlk.Update();
    }
}

void ChangeBlkColor(Entity entBlk, int iCol)
{
    PickSet ss(SS_FREE);
    ss+=entBlk;
    ChangeBlkColor(ss, iCol);
}

 
AcDbObjectId GetPickCirByBlk(Entity ent, XPoint ptPick)
{
	double xscale;
	ent.GetData(41, &xscale);
	xscale = fabs(xscale);

    AcDbObjectId idRet = NULL;
    AcDbObjectId Id = NULL;
    acdbGetObjectId(Id, ent);
    AcDbBlockReference *pBlkRef = NULL;
    acdbOpenObject(pBlkRef, Id, AcDb::kForRead);
    if(!pBlkRef)
        return idRet;
    AcGeMatrix3d matrix = pBlkRef->blockTransform();
    pBlkRef->close();

    TCHAR szBlkName[256];
    ent.GetData(2, szBlkName);
    AcDbBlockTableRecord *pRecord = NULL; 
    AcDbBlockTable* pBlockTable = NULL;
    acdbCurDwg()->getBlockTable(pBlockTable, AcDb::kForRead);
    if(!pBlockTable)
        return idRet;
    if(Acad::eOk != pBlockTable->getAt(szBlkName, pRecord, AcDb::kForRead)){
        pBlockTable->close();
        return idRet;
    }
    pBlockTable->close();
    if(!pRecord)
        return idRet;
    
     
    AcDbBlockTableRecordIterator *pIterator;
    pRecord->newIterator(pIterator);
    pRecord->close();
    if(!pIterator)
        return idRet;
    for(pIterator->start(); !pIterator->done(); pIterator->step()){
        AcDbEntity *pEnt = NULL;
        AcDbCircle *pCir = NULL;
        pIterator->getEntity(pEnt, AcDb::kForRead);
        if(pEnt){
            if(pCir = AcDbCircle::cast(pEnt)){
			    AcGePoint3d ptIns = pCir->center();
			    ptIns = ptIns.transformBy(matrix);
                ptIns.z = 0;
			    XCircle cir(asDblArray(ptIns), pCir->radius()*xscale);
			    if(IsPtOnCircle(ptPick, cir, 50)){
				    idRet = pEnt->objectId();
                    pEnt->close();
                    break;
			    }
            }
            pEnt->close();
        }
    }
    delete pIterator;
    return idRet;
}

BOOL GetSanitaryInfo(Entity ent, XPoint &ptRet, CString &csBlk, CString &csSysBlk, double &nRadius, double &nDang, double &nBigQ, double &dEle, int iType)
{
    double xscale;
    ent.GetData(41, &xscale);
    xscale = fabs(xscale);
  
    CString csApp;
    if(iType == 0)
        csApp = _T("SANITARYFEED");
    else if(iType == 1)
        csApp = _T("SANITARYHEADFEED");
    else if(iType == 2)
        csApp = _T("SANITARYDRAIN");
    
    BOOL bRet(FALSE);
    AcDbObjectId Id = NULL;
    acdbGetObjectId(Id, ent);
    AcDbBlockReference *pBlkRef = NULL;
    acdbOpenObject(pBlkRef, Id, AcDb::kForRead);
    if(!pBlkRef)
        return FALSE;
    AcGeMatrix3d matrix = pBlkRef->blockTransform();
    pBlkRef->close();

    TCHAR szBlkName[256];
    ent.GetData(2, szBlkName);
    AcDbBlockTableRecord *pRecord = NULL; 
    AcDbBlockTable* pBlockTable = NULL;
    acdbCurDwg()->getBlockTable(pBlockTable, AcDb::kForRead);
    if(!pBlockTable)
        return FALSE;
    if(Acad::eOk != pBlockTable->getAt(szBlkName, pRecord, AcDb::kForRead)){
        pBlockTable->close();
        return FALSE;
    }
    pBlockTable->close();
    if(!pRecord)
        return FALSE;
    
     
    AcDbBlockTableRecordIterator *pIterator;
    pRecord->newIterator(pIterator);
    pRecord->close();
    if(!pIterator)
        return FALSE;
    for(pIterator->start(); !pIterator->done(); pIterator->step()){
        AcDbEntity *pEnt = NULL;
        pIterator->getEntity(pEnt, AcDb::kForRead);
        if(pEnt){
            AcDbPoint *pll = NULL;
            AcDbCircle *pCir = NULL;
            if(pCir = AcDbCircle::cast(pEnt)){
                if(iType == 2){
                    resbuf  *pRb = pEnt->xData(csApp);
                    if(pRb) {
                        resbuf *pNext = pRb->rbnext;
                        if(pNext && pNext->restype == 1000)  {
                            csBlk = pNext->resval.rstring;        
                            pNext = pNext->rbnext;
                            if(pNext && pNext->restype == 1000)  {
                                csSysBlk = pNext->resval.rstring; 
                                pNext = pNext->rbnext;
                            }
                            if(pNext && pNext->restype == 1040)  {
                                nDang = pNext->resval.rreal;      
                                pNext = pNext->rbnext;
                            }
                            if(pNext && pNext->restype == 1040)  {
                                nBigQ = pNext->resval.rreal;      
                            }
                        }
                        ads_relrb(pRb);
                        AcGePoint3d ptIns = pCir->center();
                        nRadius = pCir->radius()*xscale;
                        ptIns = ptIns.transformBy(matrix);
                        ptRet = ptIns;
                        bRet = TRUE;
                        pEnt->close();
                        break;
                    }
                }
            }
            else if(pll = AcDbPoint::cast(pEnt)){
                resbuf  *pRb = pEnt->xData(csApp);
                if(pRb) {
                    resbuf *pNext = pRb->rbnext;
                    if(pNext && pNext->restype == 1000)  {
                        csBlk = pNext->resval.rstring;        
                        pNext = pNext->rbnext;
                        if(pNext && pNext->restype == 1000) { 
                            csSysBlk = pNext->resval.rstring;  
                            pNext = pNext->rbnext;
                        }
                        if(pNext && pNext->restype == 1040)  {
                            nDang = pNext->resval.rreal;      
                            pNext = pNext->rbnext;
                        }
                        if(pNext && pNext->restype == 1040)  {
                            nBigQ = pNext->resval.rreal;   
							pNext = pNext->rbnext;
                        }
                        if(pNext && pNext->restype == 1040)  {//sr 2010-7-9 把标高从z改为扩展数据
                            dEle = pNext->resval.rreal;      
                        }
                    }
                    ads_relrb(pRb);
					nDang = fabs(nDang);
                    AcGePoint3d ptIns = pll->position();
                    ptIns = ptIns.transformBy(matrix);
                    
                    ptRet = ptIns;
                    bRet = TRUE;
                    pEnt->close();
                    break;
                }
                
            }
            pEnt->close();
        }
    }
    delete pIterator;
    return bRet;
}

// 获取图层是否锁定的状态，并修改其锁定状态 zxl 2012.11.19 add
bool CheckAndSetLayerUnlock(const CString &sName, const bool bLock)
{
	bool bLocked = false;
	AcDbLayerTable *pTable = NULL;
	AcDbLayerTableRecord *pRecord = NULL;
	acdbCurDwg()->getLayerTable(pTable, AcDb::kForRead);
    if(!pTable)
        return false;
	
	if(Acad::eOk != pTable->getAt(sName, pRecord, AcDb::kForWrite)){
        pTable->close();
        return false;
    }
	pTable->close();

	if(!pRecord)
        return false;
	bLocked = pRecord->isLocked();
	if (bLocked && !bLock)
	{
		pRecord->setIsLocked(false);
	}

	if (bLock)
	{
		pRecord->setIsLocked(true);
	}
	pRecord->close();
	return bLocked;
}

void ClearSanitaryInfo(Entity ent)
{
    TCHAR szBlkName[256];
    ent.GetData(2, szBlkName);
    AcDbBlockTableRecord *pRecord = NULL; 
    AcDbBlockTable* pBlockTable = NULL;
    acdbCurDwg()->getBlockTable(pBlockTable, AcDb::kForRead);
    if(!pBlockTable)
        return;
    if(Acad::eOk != pBlockTable->getAt(szBlkName, pRecord, AcDb::kForRead)){
        pBlockTable->close();
        return;
    }
    pBlockTable->close();
    if(!pRecord)
        return;
    
    AcDbBlockTableRecordIterator *pIterator;
    pRecord->newIterator(pIterator);
    pRecord->close();
    if(!pIterator)
        return;

	bool bLayerLocked = false;
    for(pIterator->start(); !pIterator->done(); pIterator->step()){
        AcDbEntity *pEnt = NULL;
        pIterator->getEntity(pEnt, AcDb::kForRead);
        if(pEnt){
			bLayerLocked = CheckAndSetLayerUnlock(pEnt->layer(), false);
            AcDbPoint *pll = NULL;
            AcDbCircle *pCir = NULL;
            if(pll = AcDbPoint::cast(pEnt)){
                if(pll->upgradeOpen()==Acad::eOk) {
                    pll->erase();     
                    pll->downgradeOpen();
                }
            }
            else if(pCir = AcDbCircle::cast(pEnt)){
                resbuf  *pRb = pEnt->xData(_T("SANITARYDRAIN"));
                if(pRb) {
                    if(pCir->upgradeOpen()==Acad::eOk) {
                        resbuf *pXData = ads_buildlist(1001, _T("SANITARYDRAIN"), NULL);
                        pCir->setXData(pXData);
                        ads_relrb(pXData);
                        pCir->downgradeOpen();
                    }
                    ads_relrb(pRb);
                }
            }
            pEnt->close();
			if (bLayerLocked)
			{
				CheckAndSetLayerUnlock(pEnt->layer(), true);
				bLayerLocked = false;
			}
        }
    }
    delete pIterator;
    return;
}

BOOL SetDrainCirInBlk(Entity entBlk, AcDbObjectId IdCir, const TCHAR* szBlk, const TCHAR* szSysBlk, double nDang, double nBigQ)
{
    AcDbObjectId idRet = NULL;
    AcDbObjectId Id = NULL;
    acdbGetObjectId(Id, entBlk);
    AcDbBlockReference *pBlkRef = NULL;
    acdbOpenObject(pBlkRef, Id, AcDb::kForRead);
    if(!pBlkRef)
        return FALSE;
    AcGeMatrix3d matrix = pBlkRef->blockTransform();
    pBlkRef->close();

    TCHAR szBlkName[256];
    entBlk.GetData(2, szBlkName);
    AcDbBlockTableRecord *pRecord = NULL; 
    AcDbBlockTable* pBlockTable = NULL;
    acdbCurDwg()->getBlockTable(pBlockTable, AcDb::kForRead);
    if(!pBlockTable)
        return FALSE;
    if(Acad::eOk != pBlockTable->getAt(szBlkName, pRecord, AcDb::kForRead)){
        pBlockTable->close();
        return FALSE;
    }
    pBlockTable->close();
    if(!pRecord)
        return FALSE;
    
     
    AcDbBlockTableRecordIterator *pIterator;
    pRecord->newIterator(pIterator);
    pRecord->close();
    if(!pIterator)
        return FALSE;
    BOOL bRet = FALSE;
    for(pIterator->start(); !pIterator->done(); pIterator->step()){
        AcDbEntity *pEnt = NULL;
        AcDbCircle *pCir = NULL;
        pIterator->getEntity(pEnt, AcDb::kForRead);
        if(pEnt){
            if(pCir = AcDbCircle::cast(pEnt)){
                if(IdCir == pEnt->objectId()){
                    if(pCir->upgradeOpen()==Acad::eOk) {
                        if(!XSymbolTable(_T("APPID"), _T("SANITARYDRAIN")))
                            ads_regapp(_T("SANITARYDRAIN"));
                        resbuf *pXData = ads_buildlist(1001, _T("SANITARYDRAIN"), 1000, szBlk, 1000, szSysBlk, 1040, nDang, 1040, nBigQ, NULL);
                        pCir->setXData(pXData);
                        ads_relrb(pXData);
                        pCir->downgradeOpen();
                        bRet = TRUE;
                    }
                }
            }
            pEnt->close();
        }
    }
    delete pIterator;
    return bRet;    
}

BOOL AddPointInBlk(Entity entBlk, AcGePoint3d ptIns, const TCHAR* szBlk, const TCHAR* szSysBlk, double nDang, double nBigQ, int iType)
{
	if(fabs(ptIns.x) < 0.001 &&  fabs(ptIns.y) < 0.001)
		return FALSE;
	//sr 2010-7-9 把标高从z改为扩展数据
	double dEle = ptIns.z;
	
    AcDbObjectId Id = NULL;
    acdbGetObjectId(Id, entBlk);
    AcDbBlockReference *pBlkRef = NULL;
    acdbOpenObject(pBlkRef, Id, AcDb::kForRead);
    if(!pBlkRef)
        return FALSE;
    AcGeMatrix3d matrix = pBlkRef->blockTransform();
    pBlkRef->close();

    matrix = matrix.inverse();
    TCHAR szBlkName[256];
    entBlk.GetData(2, szBlkName);
    AcDbBlockTable*        pBlockTable = NULL;
    AcDbBlockTableRecord*  pRecord = NULL;
    AcDbObjectId objId = NULL;
    acdbCurDwg()->getBlockTable(pBlockTable, AcDb::kForRead);
    if(!pBlockTable)
        return FALSE;
    pBlockTable->getAt(szBlkName, pRecord, AcDb::kForWrite);
    pBlockTable->close();
    if(!pRecord)
        return FALSE;
    ptIns = ptIns.transformBy(matrix);
    AcDbPoint *pNewPt = new AcDbPoint();
    pNewPt->setPosition(ptIns);
	


    CString csApp;
    if(iType == 0)
        csApp = _T("SANITARYFEED");
    else if(iType == 1)
        csApp = _T("SANITARYHEADFEED");
    else if(iType == 2)
        csApp = _T("SANITARYDRAIN");

    if(!XSymbolTable(_T("APPID"), csApp))
        ads_regapp(csApp);

    resbuf *pXData = ads_buildlist(1001, csApp, 1000, szBlk, 1000, szSysBlk, 1040, nDang, 1040, nBigQ, 1040, dEle, NULL);
    pNewPt->setXData(pXData);
    ads_relrb(pXData);
    
    pRecord->appendAcDbEntity(objId, pNewPt);
    pRecord->close();
    pNewPt->close(); 
    return TRUE;
}




//***************************************************************************************************
//                                        定义洁具
//***************************************************************************************************

void DefineSanitary()
{
    Entity ent;

    RBList rbMask = ads_buildlist( -4, _T("<or"),
        -4, _T("<and"), RTDXF0, _T("INSERT"), -4, _T("and>"),  
        -4, _T("<and"), RTDXF0, _T("AEC_BLOCK_INSERT"), -4, _T("and>"),  
        -4, _T("or>"), NULL);
	if(SelectEntity(_T("\n请选择要定义的洁具图块(本图每种洁具只需定义一次):<退出>"), ent, rbMask) != RTNORM)
        return;
    XPoint ptTmp;
    CString csTmp1, csTmp2;
    double nTmp(0), nDang(0), nBigQ(0), dEle(0);
    CTemporaryResourceOverride vTemp;
    CSanitaryDefineDlg dlg;
    dlg.m_ent = ent;

    if(!GetSanitaryInfo(ent, ptTmp, csTmp1, csTmp2, nTmp, nDang, nBigQ, dEle, 0)){
        CTemporaryResourceOverride vTemp2;
        CSanitaryTypeDlg dlg2;
        if(dlg2.DoModal() != IDOK)
            return;
        dlg.m_csSysBlk1 = dlg2.m_csSysBlk1;
        dlg.m_csSysBlk2 = dlg2.m_csSysBlk2;
        dlg.m_nDang = dlg2.m_nDang;
        dlg.m_iType = dlg2.m_iType;
        dlg.m_nNg = dlg2.m_nNg;
        dlg.m_nBigQ = dlg2.m_nBigQ;
		dlg.m_dRateQ = dlg2.m_dRateQ;
    }
    
    if(dlg.DoModal() != IDOK)
        return;
    if(!dlg.m_ptFeed){
        adsout << _T("\n没有指定给水点!");
        return;
    }
    if(!dlg.m_id && !dlg.m_ptDrain){
        adsout << _T("\n没有指定排水点或排水圆圈!");
        return;
    }

	if(dlg.m_iFeedElev == 1)
	{
		dlg.m_ptFeed.z = dlg.m_dFeedElev;
		dlg.m_ptHeatFeed.z = dlg.m_dFeedElev;
	}
	else
	{
		dlg.m_ptFeed.z = 0;
		dlg.m_ptHeatFeed.z = 0;
	}
    ClearSanitaryInfo(ent);
	
	double xscale, yscale;
    ent.GetData(41, &xscale);
    ent.GetData(42, &yscale);
	BOOL bMirror = FALSE;
	if(ent.Is(_T("INSERT")))
	{
		if(xscale < 0)
			bMirror = TRUE;
	}
	else if(ent.Is(_T("AEC_BLOCK_INSERT")))
	{
		if(yscale < 0)
			bMirror = TRUE;
	}
	
    if(!!dlg.m_ptFeed)
	{
		double dNg = dlg.m_nDang;
		if(bMirror)
			dNg =  dNg * -1;
        AddPointInBlk(ent, asPnt3d(dlg.m_ptFeed), dlg.m_csBlkName, dlg.m_csSysBlk1, dNg, dlg.m_dRateQ, 0);
	}
    if(!!dlg.m_ptHeatFeed){
		//2008-4-9 sr add  对于混水龙头, 不需要热水再绘制一遍
		CString csSysBlk = dlg.m_csSysBlk1;
		if(csSysBlk == _T("TWTSYS(00000016)") || csSysBlk == _T("TWTSYS(00000200)") 
		|| csSysBlk == _T("TWTSYS(00000467)")|| csSysBlk == _T("TWTSYS(00000471)")
		|| csSysBlk == _T("TWTSYS(00000204)")|| csSysBlk == _T("TWTSYS(00000208)")
		|| csSysBlk == _T("TWTSYS(00000344)")|| csSysBlk == _T("TWTSYS(00000463)"))
			csSysBlk = _T("");
        AddPointInBlk(ent, asPnt3d(dlg.m_ptHeatFeed), dlg.m_csBlkName, csSysBlk, dlg.m_nDang, 0, 1);
	}
    if(dlg.m_id)
        SetDrainCirInBlk(ent, dlg.m_id, dlg.m_csDrainBlk, dlg.m_csSysBlk2, dlg.m_nNg, dlg.m_nBigQ);
    else if(!!dlg.m_ptDrain)
        AddPointInBlk(ent, asPnt3d(dlg.m_ptDrain), dlg.m_csDrainBlk, dlg.m_csSysBlk2, dlg.m_nNg, dlg.m_nBigQ, 2);

    TCHAR szBlkName[256];
    ent.GetData(2, szBlkName);

    RBList rbMask2 = ads_buildlist( -4, _T("<or"),
        -4, _T("<and"), RTDXF0, _T("INSERT"), 8, _T("*"), 2, szBlkName, -4, _T("and>"),  
        -4, _T("<and"), RTDXF0, _T("AEC_BLOCK_INSERT"), 8, _T("*"), 2, szBlkName, -4, _T("and>"),  
        -4, _T("or>"), NULL);

    PickSet ssAll(SS_FREE);
    ssAll.Get(_T("X"), NULL, NULL, rbMask2);
    long len = ssAll.Length();
    for(long i=0;i<len;i++){
        Entity entBlk = ssAll[i];
        OPENOBJ_BEGIN(entBlk, AcDb::kForWrite, AcDbBlockReference, pBlk);
        if(pBlk){
            pBlk->setColorIndex(4);
        }
        OPENOBJ_END();
    }
    
    ChangeBlkColor(ssAll, 0);//随块

}

/////////////////////////////////////////////////////////////////////////////
// CSanitaryDefineDlg dialog


CSanitaryDefineDlg::CSanitaryDefineDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CSanitaryDefineDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CSanitaryDefineDlg)
	m_iType = 0;
	m_nDang = 0.5;
	m_nBigQ = 0.0;
	m_nNg = 0.0;
	m_dRateQ = 0.0;
	m_dFeedElev = -1;
	m_iFeedElev = 0;
	//}}AFX_DATA_INIT
    m_csSysBlk1 = _T("TWTSYS(00000005)"); //水龙头
    m_csSysBlk2 = _T("TWTSYS(00000101)"); //排水点

    CString csDwb = g_csDwbPath + _T("TwtSys");
    XString xsTmp, xsTmp1, xsTmp2;
	if(LoadDwbBlock(csDwb, _T("00000320"), xsTmp1) != RTNORM)// 
		return;
	if(LoadDwbBlock(csDwb, _T("00000002"), xsTmp2) != RTNORM)//  
		return;
	if(LoadDwbBlock(csDwb, _T("00000147"), xsTmp) != RTNORM) //排水点
		return;

    m_csBlkName = (const TCHAR*)xsTmp1;
    m_csDrainBlk = (const TCHAR*)xsTmp;
}


void CSanitaryDefineDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CSanitaryDefineDlg)
	DDX_Radio(pDX, IDC_RADIO_TYPE1, m_iType);
	DDX_Text(pDX, IDC_EDIT_DANG, m_nDang);
	DDX_Text(pDX, IDC_EDIT_BIGQ, m_nBigQ);
	DDX_Text(pDX, IDC_EDIT_NG, m_nNg);
	DDX_Text(pDX, IDC_EDIT_RATEQ, m_dRateQ);
	DDX_Text(pDX, IDC_EDIT_FEED_ELEV, m_dFeedElev);
	DDX_Radio(pDX, IDC_RADIO_FEEDELE1, m_iFeedElev);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CSanitaryDefineDlg, CDialog)
	//{{AFX_MSG_MAP(CSanitaryDefineDlg)
	ON_WM_PAINT()
	ON_BN_CLICKED(IDC_PREVIEW2, OnPreview2)
	ON_BN_CLICKED(IDC_PREVIEW3, OnPreview3)
	ON_BN_CLICKED(IDC_RADIO_TYPE1, OnRadioType1)
	ON_BN_CLICKED(IDC_BUTTON_PICK1, OnButtonPick1)
	ON_BN_CLICKED(IDC_BUTTON_PICK2, OnButtonPick2)
	ON_BN_CLICKED(IDC_BUTTON_PICK3, OnButtonPick3)
	ON_BN_CLICKED(IDC_BUTTON_DANG, OnButtonDang)
	ON_BN_CLICKED(IDC_RADIO_TYPE3, OnRadioType3)
	ON_BN_CLICKED(IDC_BUTTON_PICK4, OnButtonPick4)
	ON_BN_CLICKED(IDC_BUTTON_NG, OnButtonNg)
	ON_BN_CLICKED(IDC_RADIO_TYPE4, OnRadioType4)
	ON_BN_CLICKED(IDC_RADIO_FEEDELE1, OnRadioFeedele1)
	ON_BN_CLICKED(IDC_RADIO_FEEDELE2, OnRadioFeedele2)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CSanitaryDefineDlg message handlers

BOOL CSanitaryDefineDlg::OnInitDialog() 
{
	CDialog::OnInitDialog();
    CString csTmp1, csTmp2;
    double nTmp, dEle(0);
    GetSanitaryInfo(m_ent, m_ptHeatFeed, csTmp1, csTmp2, nTmp, m_nDang, m_nBigQ, dEle, 1);
    if(GetSanitaryInfo(m_ent, m_ptFeed, csTmp1, csTmp2, nTmp, m_nDang, m_dRateQ, m_dFeedElev, 0)){
        m_csBlkName = csTmp1;
        m_csSysBlk1 = csTmp2;
        if(m_csBlkName == _T("$TWTSYS$00000320"))
            m_iType = 0;
        else if(m_csBlkName == _T("$TWTSYS$00000225"))
            m_iType = 1;
        else
            m_iType = 2;

	//	m_dFeedElev = m_ptFeed.z;
		if(m_dFeedElev > 0.001)
			m_iFeedElev = 1;
		
    }
    if(GetSanitaryInfo(m_ent, m_ptDrain, csTmp1, csTmp2, nTmp, m_nNg, m_nBigQ, dEle, 2)){
        m_csSysBlk2 = csTmp2;
    }
    UpdateData(FALSE);
	OpenSlide();
	
	CWnd *pWnd = GetDlgItem(IDC_EDIT_FEED_ELEV);
	if(m_iFeedElev == 0)
		pWnd->EnableWindow(FALSE);
	else
		pWnd->EnableWindow(TRUE);
	
	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

void CSanitaryDefineDlg::OnPaint() 
{
	CPaintDC dc(this); // device context for painting
	OpenSlide();
}

void CSanitaryDefineDlg::OpenSlide()
{
    CWnd *pImageBox1 = GetDlgItem(IDC_PREVIEW2);
    CWnd *pImageBox2 = GetDlgItem(IDC_PREVIEW3);
    CWnd *pImageBox3 = GetDlgItem(IDC_PREVIEW1);
    DrawSlide((const TCHAR*)m_csSysBlk1, pImageBox1);
    DrawSlide((const TCHAR*)m_csSysBlk2, pImageBox2);
    UpdateData(TRUE);
    CString csTmp;
    if(m_iType == 0){
        m_csBlkName = _T("$TWTSYS$00000320");
        csTmp = _T("TWTSYS(00000320)");
    }
    else if(m_iType == 1){
        m_csBlkName = _T("$TWTSYS$00000225");
        csTmp = _T("TWTSYS(00000225)");
    }
    else if(m_iType == 2){
        m_csBlkName = _T("$TWTSYS$00000519");
        csTmp = _T("TWTSYS(00000519)");
    }
    DrawSlide((const TCHAR*)csTmp, pImageBox3);
}

void CSanitaryDefineDlg::OnPreview3() 
{
    UpdateData();
    CTemporaryResourceOverride vTemp;
    CSelectBlkDlg dlg;  
    dlg.m_csTkName = _T("TWTSYS");
    dlg.m_csType = _T("排水点\\90度");	
    CWnd *pWnd = GetDlgItem(IDC_PREVIEW3);
    CRect rect;
    dlg.m_staticSlide.m_csCurRecord = m_csSysBlk2;
    pWnd->GetWindowRect(&rect);
    dlg.m_ptBase = rect.TopLeft();
    if(dlg.DoModal() == IDOK){
        CString csRet = dlg.m_staticSlide.m_csCurRecord;
        XString xsTKName, xsRocord;
        SplitSlbName(csRet, xsTKName, xsRocord);
        csRet.Format(_T("%s(%s)"), dlg.m_csTkName, xsRocord);
        
        m_csSysBlk2 = csRet;
        OpenSlide();
    }
}

void CSanitaryDefineDlg::OnPreview2() 
{
    UpdateData();
    CTemporaryResourceOverride vTemp;
    CSelectBlkDlg dlg;  
    dlg.m_staticSlide.m_iRowNum = 4;
    dlg.m_staticSlide.m_iColNum = 4;
    dlg.m_csTkName = _T("TWTSYS");
    dlg.m_csType = _T("给水点\\90度");
    
    CWnd *pWnd = GetDlgItem(IDC_PREVIEW2);
    CRect rect;
    dlg.m_staticSlide.m_csCurRecord = m_csSysBlk1;
    pWnd->GetWindowRect(&rect);
    dlg.m_ptBase = rect.TopLeft();
    if(dlg.DoModal() == IDOK){
        CString csRet = dlg.m_staticSlide.m_csCurRecord;
        XString xsTKName, xsRocord;
        SplitSlbName(csRet, xsTKName, xsRocord);
        csRet.Format(_T("%s(%s)"), dlg.m_csTkName, xsRocord);
        
        m_csSysBlk1 = csRet;
        OpenSlide();
    }
    
}

void CSanitaryDefineDlg::OnRadioType1() 
{
	OpenSlide();
}

void CSanitaryDefineDlg::OnRadioType3() 
{
    OpenSlide();
}

void CSanitaryDefineDlg::OnRadioType4() 
{
	OpenSlide();
}

void CSanitaryDefineDlg::OnButtonPick1() 
{
	UpdateData(TRUE);	
	HideDialog(this, TRUE);
    XPoint ptCen, pt1, pt2;
    m_ent.GetExtend(pt1, pt2);
    XLine line(pt1, pt2, 1);
    line.MidPoint(ptCen);
    if(!!m_ptFeed){
        ptCen = m_ptFeed;
        m_ptFeed = XPoint();
    }
    while(!m_ptFeed){
		int ret = ads_getpoint(ptCen, _T("\n请点取冷水给水点位置:<中心>"), m_ptFeed);
        m_ptFeed = Ucs2Wcs(m_ptFeed);
        if(ret == RTNONE)
            m_ptFeed = ptCen;
    }
	HideDialog(this, FALSE);
	UpdateData(FALSE);		
}

void CSanitaryDefineDlg::OnButtonPick4() 
{
    UpdateData(TRUE);	
    HideDialog(this, TRUE);
    XPoint ptCen, pt1, pt2;
    m_ent.GetExtend(pt1, pt2);
    XLine line(pt1, pt2, 1);
    line.MidPoint(ptCen);
    if(!!m_ptHeatFeed){
        ptCen = m_ptHeatFeed;
        m_ptHeatFeed = XPoint();
    }
    while(!m_ptHeatFeed){
		int ret = ads_getpoint(ptCen, _T("\n请点取热水给水点位置:<中心>"), m_ptHeatFeed);
        m_ptHeatFeed = Ucs2Wcs(m_ptHeatFeed);
        if(ret == RTNONE)
            m_ptHeatFeed = ptCen;
    }
    HideDialog(this, FALSE);
    UpdateData(FALSE);		
}

void CSanitaryDefineDlg::OnButtonPick2() 
{
	UpdateData(TRUE);	
	HideDialog(this, TRUE);

    XPoint ptCen, pt1, pt2;
    m_ent.GetExtend(pt1, pt2);
    XLine line(pt1, pt2, 1);
    line.MidPoint(ptCen);
    if(!!m_ptDrain){
        ptCen = m_ptDrain;
        m_ptDrain = XPoint();
    }

    while(!m_ptDrain){
		int ret = ads_getpoint(ptCen, _T("\n请点取排水点位置:<中心>"), m_ptDrain);
        m_ptDrain = Ucs2Wcs(m_ptDrain);
        if(ret == RTNONE)
            m_ptDrain = ptCen;
    }
	HideDialog(this, FALSE);
	UpdateData(FALSE);			
}

void CSanitaryDefineDlg::OnButtonPick3() 
{
	UpdateData(TRUE);	
	HideDialog(this, TRUE);
    TCHAR szBlkName[256];
    m_ent.GetData(2, szBlkName);

    RBList rbMask = ads_buildlist( -4, _T("<or"),
        -4, _T("<and"), RTDXF0, _T("INSERT"), 8, _T("*"), 2, szBlkName, -4, _T("and>"),  
        -4, _T("<and"), RTDXF0, _T("AEC_BLOCK_INSERT"), 8, _T("*"), 2, szBlkName, -4, _T("and>"),  
        -4, _T("or>"), NULL);
    XPoint ptPick1;
    Entity ent;
	if(SelectEntity1(_T("\n请选择洁具图块上的排水圆圈:<退出>"), ent, ptPick1, rbMask) == RTNORM){
        if(ent == m_ent){
            m_id = GetPickCirByBlk(ent, ptPick1);
        }
    }
	HideDialog(this, FALSE);
	UpdateData(FALSE);			
}
			


void CSanitaryDefineDlg::OnButtonDang() 
{
    CTemporaryResourceOverride vTemp;
    CSanitaryDangDlg dlg;
    if(dlg.DoModal() == IDOK && dlg.m_nRet > 0){
        m_nDang = dlg.m_nRet;
        m_dRateQ = dlg.m_nRet2;
        UpdateData(FALSE);			
    }
}



void CSanitaryDefineDlg::OnButtonNg() 
{
    CTemporaryResourceOverride vTemp;
    CSanitaryDangDlg dlg;
    dlg.m_iMode = 1;
    if(dlg.DoModal() == IDOK){
        m_nNg = dlg.m_nRet;
        m_nBigQ = dlg.m_nRet2;
        UpdateData(FALSE);
    }
}


void CSanitaryDefineDlg::OnRadioFeedele1() 
{
	UpdateData();
	CWnd *pWnd = GetDlgItem(IDC_EDIT_FEED_ELEV);
	if(m_iFeedElev == 0)
		pWnd->EnableWindow(FALSE);
	else
		pWnd->EnableWindow(TRUE);
}

void CSanitaryDefineDlg::OnRadioFeedele2() 
{
	UpdateData();
	CWnd *pWnd = GetDlgItem(IDC_EDIT_FEED_ELEV);
	if(m_iFeedElev == 0)
		pWnd->EnableWindow(FALSE);
	else
		pWnd->EnableWindow(TRUE);
	
}