//---------------------------------------------------------------------------


#pragma hdrstop

#include "CDSNodeF.h"
#include "AppGlobalF.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)

TItsNode::TItsNode()
{
    TItsNode("");
}
//---------------------------------------------------------------------------
TItsNode::TItsNode(String AId)
{
    FNODE_ID   = AId;
    Clear();
    FModified = false;
    FCompleted= false;
}
//---------------------------------------------------------------------------
void TItsNode::Clear()
{
#if 0
    FNODE_TYPE = "";
    FNODE_NAME = "";
    FTURN_P    = "";
    FRMRK      = "";
    FX_CRDN    = "0";
    FY_CRDN    = "0";
#endif
}
//---------------------------------------------------------------------------
TItsNode::~TItsNode()
{
}
//---------------------------------------------------------------------------
void TItsNode::SetValue(String &AOrgValue, String AValue)
{
    if (AOrgValue != AValue)
    {
        AOrgValue = AValue;
        if (FCompleted) FModified = true;
    }
}
//---------------------------------------------------------------------------
void TItsNode::SetFNODE_ID(String AValue)
{
    SetValue(FNODE_ID, AValue);
}
//---------------------------------------------------------------------------
void TItsNode::SetFNODE_TYPE(String AValue)
{
    SetValue(FNODE_TYPE, AValue);
}
//---------------------------------------------------------------------------
void TItsNode::SetFNODE_NAME(String AValue)
{
    SetValue(FNODE_NAME, AValue);
}
//---------------------------------------------------------------------------
void TItsNode::SetFTURN_P(String AValue)
{
    SetValue(FTURN_P, AValue);
}
//---------------------------------------------------------------------------
void TItsNode::SetFRMRK(String AValue)
{
    SetValue(FRMRK, AValue);
}
//---------------------------------------------------------------------------
void TItsNode::SetFX_CRDN(String AValue)
{
    SetValue(FX_CRDN, AValue);
}
//---------------------------------------------------------------------------
void TItsNode::SetFY_CRDN(String AValue)
{
    SetValue(FY_CRDN, AValue);
}
//---------------------------------------------------------------------------


TItsNodeList::TItsNodeList()
{
    FList = new TList();
}
//---------------------------------------------------------------------------
TItsNodeList::~TItsNodeList()
{
    ReleaseAll();
    delete FList;
}
//---------------------------------------------------------------------------
void TItsNodeList::ReleaseAll()
{
    for(int ii = 0; ii < Count; ii++)
        Release(ii);

    FList->Clear();
}
//---------------------------------------------------------------------------
void TItsNodeList::Release(int AIndex)
{
    if (AIndex >= 0 && AIndex < Count)
        delete (TItsNode*)FList->Items[AIndex];
}
//---------------------------------------------------------------------------
TItsNode *TItsNodeList::GetNode(int AIndex)
{
    if (AIndex >= 0 && AIndex < Count)
        return (TItsNode*)FList->Items[AIndex];

    return NULL;
}
//---------------------------------------------------------------------------
int TItsNodeList::GetCount()
{
    return FList->Count;
}
//---------------------------------------------------------------------------
void TItsNodeList::Clear()
{
    ReleaseAll();
}
//---------------------------------------------------------------------------
int TItsNodeList::Add(TItsNode *AItsNode)
{
    int nRes;
    nRes = FList->Add(AItsNode);
    return nRes;
}
//---------------------------------------------------------------------------
void TItsNodeList::Delete(int AIndex)
{
    if (AIndex >= 0 && AIndex < Count)
    {
        Release(AIndex);
        FList->Delete(AIndex);
    }
}
//---------------------------------------------------------------------------
void TItsNodeList::Insert(int AIndex, TItsNode *AItsNode)
{
    if (AIndex >= 0 && AIndex < Count)
        FList->Insert(AIndex, AItsNode);
}
//---------------------------------------------------------------------------

TCDSNode::TCDSNode(TItsNodeList *AList) 
{
    FNodes = AList;
}
//---------------------------------------------------------------------------
void *__fastcall TCDSNode::AppendRecord(void)
{
    TItsNode *ANode = new TItsNode();
    TcxDataRecordHandle *Result = (TcxDataRecordHandle*)FNodes->Add(ANode);
    DataChanged();
    if (!Modified) FModified = true;
    return Result;
}
//---------------------------------------------------------------------------
void *__fastcall TCDSNode::InsertRecord(void * ARecordHandle)
{
    TItsNode *ANode = new TItsNode();
    FNodes->Insert((int)ARecordHandle, ANode);
    TcxDataRecordHandle *Result = (TcxDataRecordHandle*)ARecordHandle;
    DataChanged();
    if (!Modified) FModified = true;
    return Result;
}
//---------------------------------------------------------------------------
void __fastcall TCDSNode::DeleteRecord(void * ARecordHandle)
{
    FNodes->Delete((int)ARecordHandle);
    DataChanged();
    if (!Modified) FModified = true;
}
//---------------------------------------------------------------------------

int __fastcall TCDSNode::GetRecordCount(void)
{
    return FNodes->Count;
}
//---------------------------------------------------------------------------

Variant __fastcall TCDSNode::GetValue(void * ARecordHandle, void * AItemHandle)
{
    int AColumnId = GetDefaultItemID((int)AItemHandle);
    TItsNode *ANode = FNodes->Node[(int)ARecordHandle];
    Variant Result;
#if 0
    switch (AColumnId) 
    {
    case IndexOfID:
      Result = ACustomer->ID; break;
    case IndexOfName:
      Result = ACustomer->Name; break;
    case IndexOfDescription:
      Result = ACustomer->Description; break;
    }
#else
    Result = ANode->NODE_ID;
#endif
    return (Result);
}
//---------------------------------------------------------------------------
void __fastcall TCDSNode::SetValue(void * ARecordHandle, void * AItemHandle, const Variant &AValue)
{
    int AColumnId = GetDefaultItemID((int)AItemHandle);
    TItsNode *ANode = FNodes->Node[(int)ARecordHandle];
#if 0
    switch (AColumnId) 
    {
    case IndexOfID:
        if (VarIsNull(AValue))
            ACustomer->ID = 0;
        else
            ACustomer->ID = AValue; 
        break;
    case IndexOfName:
        ACustomer->Name = VarToStr(AValue); 
        break;
    case IndexOfDescription:
        ACustomer->Description = VarToStr(AValue); 
        break;
    }
#else
#endif
    if (!Modified) FModified = true;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
TItsNodeManager *ItsNodeManager = NULL;
//---------------------------------------------------------------------------

/*
* Link Manager
*/
TItsNodeManager::TItsNodeManager()
{
}
//---------------------------------------------------------------------------
TItsNodeManager::~TItsNodeManager()
{
}
//---------------------------------------------------------------------------
bool TItsNodeManager::LoadFromDb(TADOConnection *ADbConn/*=NULL*/)
{
    String sQry;
    TADOQuery *pADO = NULL;

    sQry = "SELECT A.NODE_ID, A.NODE_TYPE, A.NODE_NAME, \r\n"
           "       A.TURN_P, A.RMRK, A.X_CRDN, A.Y_CRDN \r\n"
           "  FROM TB_NODE A                            \r\n";
//           " ORDER BY A.NODE_ID                         \r\n";
    try
    {
        FLists.Lock();
        FLists.RemoveAll();
        try
        {
            pADO = new TADOQuery(NULL);
			pADO->Close();
            pADO->Connection = (NULL != ADbConn) ? ADbConn : ITSDb_GetConnection();
			pADO->SQL->Clear();
			pADO->SQL->Text = sQry;

			pADO->Open();
            //int nRows = pADO->RecordCount;
            for( ; !pADO->Eof; pADO->Next())
            {
				TItsNode *pNode = new TItsNode();

                pNode->FNODE_ID   = pADO->FieldByName("NODE_ID")->AsString;   //³ëµåID
                pNode->FNODE_TYPE = pADO->FieldByName("NODE_TYPE")->AsString; //³ëµåÀ¯Çü
                pNode->FNODE_NAME = pADO->FieldByName("NODE_NAME")->AsString.Trim(); //±³Â÷·Î¸íĪ
                pNode->FTURN_P    = pADO->FieldByName("TURN_P")->AsString;    //ȸÀüÁ¦ÇÑÀ¯¹«
                pNode->FRMRK      = pADO->FieldByName("RMRK")->AsString.Trim();      //ºñ°í
                pNode->FX_CRDN    = pADO->FieldByName("X_CRDN")->AsString;    //X ÁÂÇ¥
                pNode->FY_CRDN    = pADO->FieldByName("Y_CRDN")->AsString;    //Y ÁÂÇ¥

				FLists.Push(pNode->NODE_ID, pNode);
                pNode->Completed = true;
            }
        }
        catch(EDatabaseError &E)
        {
            ::PostMessage(Application->MainForm->Handle, (UINT)(WM_USER+0xF4), (WPARAM)0xB2, (LPARAM)0xB2);
            DBERRORMSG("TItsNodeManager::LoadFromDb", String(E.ClassName()), E.Message, sQry);
            throw Exception(String(E.ClassName()) + E.Message);
        }
        catch(Exception &exception)
        {
            ::PostMessage(Application->MainForm->Handle, (UINT)(WM_USER+0xF4), (WPARAM)0xB2, (LPARAM)0xB2);
            DBERRORMSG("TItsNodeManager::LoadFromDb", String(exception.ClassName()), exception.Message, sQry);
            throw Exception(String(exception.ClassName()) + exception.Message);
        }
    }
    __finally
    {
        if (pADO)
        {
            pADO->Close();
            delete pADO;
        }
        FLists.UnLock();
    }

    return true;
}
//---------------------------------------------------------------------------